<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Çağla İslamoğlu on Medium]]></title>
        <description><![CDATA[Stories by Çağla İslamoğlu on Medium]]></description>
        <link>https://medium.com/@islamoglu.cagla?source=rss-1b555f4a39fa------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*3Q_IL8ZbBIUbCMVcSfjYlQ.jpeg</url>
            <title>Stories by Çağla İslamoğlu on Medium</title>
            <link>https://medium.com/@islamoglu.cagla?source=rss-1b555f4a39fa------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 03:53:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@islamoglu.cagla/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[GitHub Actions ile Java Test Otomasyonunda SSH Tunnel Kullanarak Güvenli Veritabanı Bağlantısı…]]></title>
            <link>https://medium.com/@islamoglu.cagla/github-actions-ile-java-test-otomasyonunda-ssh-tunnel-kullanarak-g%C3%BCvenli-veritaban%C4%B1-ba%C4%9Flant%C4%B1s%C4%B1-265ba6e2b722?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/265ba6e2b722</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[composite-actions]]></category>
            <category><![CDATA[ssh-tunnel]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 17:46:10 GMT</pubDate>
            <atom:updated>2026-07-31T17:46:10.256Z</atom:updated>
            <content:encoded><![CDATA[<h3>GitHub Actions ile Java Test Otomasyonunda SSH Tunnel Kullanarak Güvenli Veritabanı Bağlantısı (Bölüm 3)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ncbakM8GgqoRAUhxUj7Gzw.png" /></figure><blockquote>Önceki bölümde geliştirici ve test mühendislerinin SSH Tunnel mimarisini lokal ortamlarında nasıl kullandığını incelemiştik. Bu bölümde ise aynı yapının GitHub Actions üzerinde nasıl otomatikleştirildiğini ele alacağız.</blockquote><blockquote>Pipeline çalıştığında framework’ün ihtiyaç duyduğu çalışma ortamı nasıl hazırlanıyor, yapılandırma dosyası nasıl oluşturuluyor ve tüm bu işlemler neden Composite Action içerisine taşınıyor adım adım inceleyeceğiz.</blockquote><h3>GitHub Actions Workflow Yapısı</h3><p>Projede testlerin çalıştırılmasından sorumlu bir GitHub Actions workflow’u bulunmaktadır.</p><p>Örneğin aşağıdaki gibi bir workflow dosyası düşünelim.</p><pre>name: API Test Automation</pre><pre>on:<br>  workflow_dispatch:</pre><pre>jobs:<br>  api-test:<br>    runs-on: ubuntu-latest</pre><pre>    steps:<br>      ...</pre><p>Bu dosya pipeline’ın giriş noktasıdır.</p><p>Workflow’un ne zaman çalışacağı, hangi işletim sistemi üzerinde çalışacağı ve hangi adımların uygulanacağı burada tanımlanır.</p><p>İlk bakışta tüm işlemleri bu dosya içerisinde gerçekleştirmek mümkün gibi görünse de zamanla farklı workflow’larda aynı hazırlık adımlarının tekrar edildiği fark edilir.</p><p>İşte bu noktada Composite Action devreye girer.</p><h3>Neden Composite Action Kullanıyoruz?</h3><p>Projede yalnızca tek bir workflow bulunmayabilir.</p><p>Örneğin;</p><ul><li>Pull Request kontrolleri</li><li>Gece çalışan regresyon testleri</li><li>Manuel tetiklenen testler</li><li>Belirli tag’lerle çalışan smoke testleri</li></ul><p>aynı hazırlık işlemlerini tekrar etmek zorunda kalabilir.</p><p>Bu hazırlıkların her workflow içerisinde yeniden yazılması yerine tamamı tek bir Composite Action altında toplanmıştır.</p><p>Böylece workflow dosyası oldukça sade kalırken tüm kurulum tek merkezden yönetilebilir.</p><p>Workflow tarafında yalnızca aşağıdaki gibi tek bir çağrı yapılması yeterlidir.</p><pre>- name: Prepare Test Environment<br>  uses: ./.github/actions/test-environment<br>  with:<br>    ...</pre><p>Bu yaklaşım sayesinde farklı workflow’lar aynı kurulum adımlarını tekrar kullanabilir.</p><h3>Composite Action’ın Giriş Parametreleri</h3><p>Composite Action hiçbir bilgiyi kendi içerisinde barındırmaz.</p><p>Framework’ün ihtiyaç duyduğu tüm bilgiler workflow tarafından parametre olarak gönderilir.</p><p>Örneğin;</p><pre>with:<br>  API_URL: ${{ secrets.API_URL }}</pre><pre>  DATABASE_URL: ${{ secrets.DATABASE_URL }}</pre><pre>  DATABASE_USERNAME: ${{ secrets.DATABASE_USERNAME }}</pre><pre>  DATABASE_PASSWORD: ${{ secrets.DATABASE_PASSWORD }}</pre><pre>  SSH_HOST: ${{ secrets.SSH_HOST }}</pre><pre>  SSH_USERNAME: ${{ secrets.SSH_USERNAME }}</pre><pre>  SSH_PRIVATE_KEY_PEM: ${{ secrets.SSH_PRIVATE_KEY_PEM }}</pre><p>Burada dikkat edilmesi gereken nokta, Composite Action’ın herhangi bir ortama bağımlı olmamasıdır.</p><p>Development, Test veya Staging ortamlarında aynı Action kullanılabilir. Değişen yalnızca gönderilen Secret değerleridir.</p><h3>Composite Action İçerisinde Neler Yapılıyor?</h3><p>Workflow bu Action’ı çağırdıktan sonra framework için gerekli çalışma ortamı hazırlanmaya başlanır.</p><p>Genel olarak aşağıdaki adımlar uygulanmaktadır.</p><pre>Java Kurulumu<br>        │<br>        ▼<br>Maven Kurulumu<br>        │<br>        ▼<br>Docker Hazırlığı<br>        │<br>        ▼<br>Configuration Dosyasının Oluşturulması<br>        │<br>        ▼<br>Testlerin Çalıştırılması</pre><p>Bu işlemler tek bir Action altında toplandığı için yeni bir workflow oluşturulurken aynı hazırlık adımlarının yeniden yazılmasına gerek kalmaz.</p><h3>Configuration Dosyası Pipeline Sırasında Nasıl Oluşturuluyor?</h3><p>Composite Action’ın en önemli görevlerinden biri framework’ün ihtiyaç duyduğu configuration.properties dosyasını hazırlamaktır.</p><p>İlk olarak repository içerisindeki örnek dosya kopyalanır.</p><pre>cp sample_configuration.properties configuration.properties</pre><p>Ardından GitHub Secrets üzerinden gelen değerler placeholder alanlarının yerine yazılır.</p><p>Örneğin;</p><pre>sed &#39;s|{DATABASE_URL}|${{ inputs.DATABASE_URL }}|g&#39;</pre><p>aynı şekilde</p><pre>sed &#39;s|{SSH_HOST}|${{ inputs.SSH_HOST }}|g&#39;</pre><p>ve diğer tüm yapılandırmalar için benzer işlemler uygulanır.</p><p>Pipeline tamamlandığında framework artık gerçek ortam bilgileriyle çalışmaya hazır hale gelir.</p><h3>Private Key Neden Ayrı İşleniyor?</h3><p>Configuration dosyasındaki değerlerin büyük bölümü tek satırlık bilgilerden oluşurken SSH Private Key çok satırlı bir PEM içeriğidir.</p><p>Bu nedenle standart sed işlemleri yerine farklı bir yöntem kullanılır.</p><p>Private Key önce environment variable olarak alınır, ardından dosyaya satır yapısı korunacak şekilde yazılır.</p><pre>content=$(cat configuration.properties)<br>        content=${content//\{SSH_PRIVATE_KEY_PEM\}/$VALUE}<br>        printf &#39;%s\n&#39; &quot;$content&quot; &gt; configuration.properties</pre><p>Bu sayede SSH anahtarında herhangi bir bozulma yaşanmadan framework tarafından kullanılabilir.</p><h3>Pipeline Artık Testleri Çalıştırmaya Hazır</h3><p>Bu noktada GitHub Actions tarafındaki hazırlık tamamlanmıştır.</p><ul><li>Çalışma ortamı hazırlanmıştır.</li><li>Java ve Maven kurulmuştur.</li><li>Gerekli Secret bilgileri alınmıştır.</li><li>configuration.properties dosyası oluşturulmuştur.</li></ul><p>Artık framework’ün ihtiyaç duyduğu tüm bilgiler hazırdır ve testler güvenli bir şekilde çalıştırılabilir.</p><p>Bir sonraki ve serinin son bölümünde Java tarafına geçeceğiz. ConfigurationProperty sınıfının bu bilgileri nasıl okuduğunu, ardından SshTunnelManager sınıfının JSch kullanarak SSH Tunnel&#39;ı nasıl oluşturduğunu satır satır inceleyeceğiz.</p><p>Bu makalede anlatılan mimarinin örnek uygulamasını içeren açık kaynak test otomasyon projesi için, <a href="https://github.com/afet-yonetim-sistemi/ays-be-api-automation">Afet Yönetim Sistemi API Test Otomasyonu</a><br>adresini ziyaret edebilirsiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=265ba6e2b722" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitHub Actions ile Java Test Otomasyonunda SSH Tunnel Kullanarak Güvenli Veritabanı Bağlantısı…]]></title>
            <link>https://medium.com/@islamoglu.cagla/github-actions-ile-java-test-otomasyonunda-ssh-tunnel-kullanarak-g%C3%BCvenli-veritaban%C4%B1-ba%C4%9Flant%C4%B1s%C4%B1-b8ac0a958461?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8ac0a958461</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[local-testing]]></category>
            <category><![CDATA[ssh-keygen]]></category>
            <category><![CDATA[ssh-tunnel]]></category>
            <category><![CDATA[test-automation]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 17:09:49 GMT</pubDate>
            <atom:updated>2026-07-22T17:09:49.625Z</atom:updated>
            <content:encoded><![CDATA[<h3>GitHub Actions ile Java Test Otomasyonunda SSH Tunnel Kullanarak Güvenli Veritabanı Bağlantısı (Bölüm 2)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9dbDJ4-jm4v3dcqK1kOCGw.png" /></figure><blockquote>İlk bölümde neden SSH Tunnel mimarisine ihtiyaç duyduğumuzu ve genel sistem tasarımını incelemiştik. Bu bölümde ise aynı mimarinin geliştirici ve test mühendislerinin kendi bilgisayarlarında nasıl kullanıldığını ele alacağız.</blockquote><h3>SSH Tunnel Sadece CI/CD Ortamı İçin mi Kullanılıyor?</h3><p>İlk makalenin ardından aldığım geri bildirimlerden biri, başlığın SSH Tunnel’ın yalnızca GitHub Actions veya diğer CI/CD ortamlarında kullanıldığı izlenimini oluşturduğu yönündeydi. Aslında durum tam olarak böyle değil. GitHub Actions bu mimariyi otomatikleştiriyor olsa da süreç çok daha önce, geliştiricinin veya test mühendisinin kendi bilgisayarında başlıyor.</p><p>Bir test mühendisi yeni bir test senaryosu geliştirdiğinde ilk yaptığı şey, yazdığı testi kendi bilgisayarında çalıştırarak doğrulamaktır. Testlerin beklenen sonucu verdiğinden emin olduktan sonra kod repository’ye gönderilir ve ardından CI/CD süreci devreye girer.</p><p>Dolayısıyla SSH Tunnel yalnızca pipeline çalışırken kullanılan bir yapı değildir. Geliştirici ve test mühendisleri de aynı SSH mimarisini kullanarak test ortamlarındaki veritabanlarına güvenli şekilde erişirler. GitHub Actions ise bu sürecin otomatik hale getirilmiş versiyonudur.</p><h3>Test Ortamındaki Veritabanına Neden Doğrudan Erişemiyoruz?</h3><p>Kurumsal projelerde test ortamlarındaki veritabanları güvenlik nedeniyle internete açılmaz. Dış dünyaya yalnızca uygulamanın API’leri erişime açık olabilir.</p><p>Örneğin aşağıdaki erişim modeli sıkça kullanılır.</p><pre>İnternet<br>    │<br>    ▼<br>API Sunucusu ✅ Erişilebilir<br>    │<br>    ▼<br>Veritabanı ❌ Kapalı</pre><p>Bu mimari sayesinde veritabanı doğrudan internete maruz kalmaz ve yalnızca yetkili sistemler veya kullanıcılar tarafından erişilebilir.</p><p>Ancak test otomasyonunda yalnızca API’den dönen cevabı doğrulamak her zaman yeterli olmayabilir. Bazı senaryolarda gerçekten kayıt oluşturulup oluşturulmadığını, verinin güncellenip güncellenmediğini veya arka planda çalışan süreçlerin beklenen değişiklikleri yapıp yapmadığını doğrudan veritabanı üzerinden kontrol etmek gerekir.</p><p>İşte bu noktada framework, veritabanına güvenli şekilde erişebilmek için SSH Tunnel kullanır.</p><h3>SSH Tunnel Nasıl Çalışır?</h3><p>Framework önce SSH sunucusuna güvenli bir bağlantı kurar.</p><pre>Test Framework<br>       │<br>       │ SSH<br>       ▼<br>SSH Sunucusu<br>       │<br>       ▼<br>   Database</pre><p>Bağlantı kurulduktan sonra veritabanı, geliştiricinin bilgisayarında açılan yerel bir port üzerinden erişilebilir hale gelir.</p><p>Örneğin yapılandırmada aşağıdaki gibi bir bağlantı tanımlanmış olabilir.</p><pre>database.url=jdbc:mysql://localhost:3306/testdb</pre><p>Buradaki localhost, geliştiricinin kendi bilgisayarındaki gerçek bir veritabanını ifade etmez.</p><p>Framework, testler başlamadan önce SSH Tunnel oluşturur ve bu bağlantıyı arka planda güvenli tünel üzerinden test ortamındaki veritabanına yönlendirir. JDBC açısından bakıldığında bağlantı yerel bir adrese yapılmış gibi görünürken, tüm trafik şifrelenmiş olarak SSH üzerinden iletilmektedir.</p><h3>SSH Kullanıcısı Nasıl Alınır?</h3><p>SSH erişimi genellikle DevOps ekipleri tarafından yönetilir.</p><p>İlk olarak geliştirici veya test mühendisi kendi bilgisayarında bir SSH anahtar çifti oluşturur.</p><pre>ssh-keygen</pre><blockquote>SSH anahtarı oluşturma adımlarını burada detaylandırmayacağım. İşletim sisteminize göre aşağıdaki resmi dokümanlardan yararlanabilirsiniz.<br><strong>Windows:</strong> <a href="https://learn.microsoft.com/en-us/windows-server/administration/openssh/openssh_keymanagement?utm_source=chatgpt.com">Microsoft Learn — Key-based authentication in OpenSSH for Windows</a><br><strong>Windows, macOS ve Linux:</strong> <a href="https://learn.microsoft.com/en-us/azure/virtual-machines/linux/create-ssh-keys-detailed?utm_source=chatgpt.com">Microsoft Learn — Generate SSH keys with ssh-keygen</a></blockquote><p>Bu işlem sonunda aşağıdaki iki dosya oluşur.</p><pre>id_rsa<br>id_rsa.pub</pre><p>Bu dosyalardan yalnızca <strong>public key (</strong><strong>.pub)</strong> DevOps ekibiyle paylaşılır. Private key hiçbir koşulda paylaşılmaz.</p><p>DevOps ekibi ilgili test ortamında kullanıcıyı oluşturduktan sonra aşağıdaki bilgileri geliştiriciyle paylaşır.</p><ul><li>SSH Host</li><li>SSH Username</li></ul><h3>Configuration Dosyası Nasıl Hazırlanır?</h3><p>Gerçek yapılandırma dosyaları güvenlik nedeniyle repository içerisinde tutulmaz. Bunun yerine yalnızca örnek bir yapılandırma dosyası (sample_configuration.properties) bulunur.</p><p>Örneğin:</p><pre>database.url={DATABASE_URL}<br><br>ssh.enabled={SSH_ENABLED}<br><br>ssh.host={SSH_HOST}<br><br>ssh.username={SSH_USERNAME}<br><br>ssh.private_key_pem={SSH_PRIVATE_KEY_PEM}<br><br>ssh.private_key_path={SSH_PRIVATE_KEY_PATH}</pre><p>Bu dosya yalnızca framework’ün hangi bilgilere ihtiyaç duyduğunu gösteren bir şablondur.</p><p>Projeyi kendi bilgisayarına alan geliştirici veya test mühendisi, bu şablonu referans alarak kendi configuration.properties dosyasını oluşturur ve kendisine iletilen bilgileri ekler.</p><pre>database.url=jdbc:mysql://localhost:3306/testdb<br><br>ssh.enabled=true<br><br>ssh.host=test-server.company.com<br><br>ssh.username=test.user<br><br>ssh.private_key_path=/Users/user/.ssh/id_rsa</pre><p>Bu sayede gerçek erişim bilgileri hiçbir zaman kaynak kod deposunda tutulmaz.</p><h3>Private Key Nasıl Kullanılır?</h3><p>Framework, SSH Private Key bilgisine üç farklı şekilde ulaşabilir.</p><p>İlk seçenek, private key içeriğinin doğrudan ssh.private_key_pem alanına verilmesidir. Bu yöntem özellikle GitHub Actions gibi CI/CD ortamlarında tercih edilir çünkü anahtar içeriği Secret olarak aktarılabilir.</p><p>İkinci seçenek ise anahtar dosyasının yolunu ssh.private_key_path özelliğiyle belirtmektir.</p><pre>ssh.private_key_path=/Users/user/.ssh/id_rsa</pre><p>Bu yöntem lokal geliştirme ortamı için en yaygın kullanılan yaklaşımdır.</p><p>Her iki özellik de boş bırakılırsa framework varsayılan SSH dizinini kontrol eder ve ~/.ssh/id_rsa veya ~/.ssh/id_ed25519 dosyalarından uygun olanı otomatik olarak kullanır.</p><h3>Testler Çalışırken Ne Oluyor?</h3><p>Tüm yapılandırma tamamlandıktan sonra test süreci geliştirici açısından oldukça basittir.</p><pre>Test Başlangıcı<br>      │<br>      ▼<br>SSH Tunnel Açılır<br>      │<br>      ▼<br>Veritabanı Bağlantısı Oluşturulur<br>      │<br>      ▼<br>Testler Çalıştırılır<br>      │<br>      ▼<br>SSH Tunnel Kapatılır</pre><p>Bu süreç tamamen framework tarafından yönetildiği için geliştiricinin terminal üzerinden manuel olarak SSH Tunnel oluşturmasına gerek kalmaz.</p><p>Bu bölümde geliştirici ve test mühendislerinin SSH Tunnel mimarisini kendi bilgisayarlarında nasıl kullandığını inceledik. Görüldüğü gibi kullanılan mimari ile CI/CD ortamında çalışan mimari arasında aslında bir fark bulunmuyor; değişen tek şey yapılandırma bilgilerinin nasıl sağlandığı.</p><p>Bir sonraki bölümde ise aynı sürecin GitHub Actions üzerinde nasıl otomatikleştirildiğini göreceğiz. sample_configuration.properties dosyasından başlayarak, GitHub Secrets, Composite Action ve çalışma anında oluşturulan configuration.properties yapısını birlikte inceleyeceğiz.</p><p>Bu makalede anlatılan mimarinin örnek uygulamasını içeren açık kaynak test otomasyon projesi için, <a href="https://github.com/afet-yonetim-sistemi/ays-be-api-automation">Afet Yönetim Sistemi API Test Otomasyonu</a><br>adresini ziyaret edebilirsiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8ac0a958461" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitHub Actions ile Java Test Otomasyonunda SSH Tunnel Kullanarak Güvenli Veritabanı Bağlantısı…]]></title>
            <link>https://medium.com/@islamoglu.cagla/github-actions-ile-java-test-otomasyonunda-ssh-tunnel-kullanarak-g%C3%BCvenli-veritaban%C4%B1-ba%C4%9Flant%C4%B1s%C4%B1-2551eefb832b?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/2551eefb832b</guid>
            <category><![CDATA[ssh-tunnel]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Wed, 15 Jul 2026 18:50:43 GMT</pubDate>
            <atom:updated>2026-07-22T15:16:23.594Z</atom:updated>
            <content:encoded><![CDATA[<h3>GitHub Actions ile Java Test Otomasyonunda SSH Tunnel Kullanarak Güvenli Veritabanı Bağlantısı (Bölüm 1)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D3o7pDsRh-k_DwOFgv-S6w.png" /></figure><p><strong>Bu seride</strong>, Java tabanlı bir test otomasyon framework’üne SSH Tunnel desteğinin nasıl eklendiğini adım adım inceleyeceğiz. GitHub Actions tarafındaki yapılandırmadan başlayarak, Configuration yönetimi, JSch kullanımı ve veritabanı bağlantısının SSH üzerinden nasıl gerçekleştirildiğini detaylı olarak ele alacağız.</p><h3>Giriş</h3><p>API test otomasyonlarında en sık karşılaşılan ihtiyaçlardan biri veritabanı doğrulamasıdır. Bir isteğin başarılı bir şekilde sonuçlandığını yalnızca HTTP durum koduna veya dönen cevaba bakarak söylemek her zaman yeterli değildir. Çoğu zaman gönderilen verinin gerçekten veritabanına kaydedildiğini veya güncellendiğini de doğrulamak gerekir.</p><p>Bu nedenle birçok test otomasyon framework’ü JDBC kullanarak doğrudan veritabanına bağlanır ve gerekli SQL sorgularını çalıştırır.</p><p>Uzun yıllardır kullanılan klasik yaklaşım oldukça basittir. Framework içerisinde veritabanı bağlantısı için gerekli bilgiler bir yapılandırma dosyasında tutulur ve JDBC bu bilgiler kullanılarak bağlantıyı oluşturur.</p><pre>database.url=jdbc:postgresql://db.company.com:5432/app_db<br>database.username=test_user<br>database.password=********</pre><p>Kod tarafında ise bağlantı genellikle aşağıdaki gibi oluşturulur.</p><pre>Connection connection =<br>    DriverManager.getConnection(<br>        databaseUrl,<br>        username,<br>        password<br>    );</pre><p>Bu yöntem küçük projeler ve geliştirme ortamları için oldukça pratiktir. Ancak proje büyüdükçe ve güvenlik gereksinimleri arttıkça bazı önemli sorunlar ortaya çıkmaya başlar.</p><h3>Doğrudan Veritabanı Bağlantısının Dezavantajları</h3><p>Kurumsal projelerde veritabanları uygulamanın en kritik bileşenlerinden biridir. Kullanıcı bilgileri, finansal veriler, log kayıtları ve iş süreçlerine ait tüm veriler burada tutulur.</p><p>Bu nedenle birçok kurum veritabanını doğrudan erişime açmak istemez.</p><p>Doğrudan bağlantı modelinde test otomasyonu veritabanına aşağıdaki yapı üzerinden erişmektedir.</p><pre> Test Automation<br>       │<br>       ▼<br>    Database</pre><p>İlk bakışta oldukça basit görünen bu yapı bazı güvenlik risklerini de beraberinde getirir.</p><ul><li>Veritabanının erişilebilir olması gerekir.</li><li>Yetkili her kullanıcı doğrudan bağlantı kurabilir.</li><li>Ortam bilgileri birçok geliştiricide bulunabilir.</li><li>CI/CD ortamlarında hassas bilgiler dikkatli yönetilmelidir.</li></ul><p>Elbette kullanıcı adı ve şifre kullanılmaktadır. Ancak günümüzde güvenlik yalnızca kullanıcı adı ve şifre ile sınırlandırılmamaktadır.</p><p>Özellikle AWS, Azure ve Google Cloud üzerinde çalışan kurumsal sistemlerde veritabanlarının doğrudan internete açılması yerine farklı güvenlik katmanları kullanılmaktadır.</p><h3>Daha Güvenli Bir Yaklaşım: SSH Tunnel</h3><p>Bu noktada devreye SSH Tunnel mimarisi girer.</p><p>SSH Tunnel, uygulamanın veritabanına doğrudan bağlanması yerine önce güvenli bir SSH oturumu oluşturmasını sağlar. Daha sonra veritabanına ait tüm trafik bu güvenli kanal üzerinden iletilir.</p><p>Bu yaklaşımda mimari aşağıdaki gibi değişmektedir.</p><pre> Test Automation<br>        │<br>        ▼<br>   SSH Tunnel<br>        │<br>        ▼<br>   SSH Server<br>        │<br>        ▼<br>     Database</pre><p>Bu yapıda test otomasyonu artık veritabanına doğrudan erişmez.</p><p>Öncelikle SSH sunucusuna güvenli bir bağlantı oluşturulur. Ardından veritabanına ait bağlantılar bu tünel üzerinden gerçekleştirilir.</p><p>Böylece veritabanı dış dünyaya açılmadan güvenli bir şekilde kullanılabilir.</p><h3>Peki GitHub Actions Bu Yapının Neresinde?</h3><p>SSH Tunnel yalnızca geliştiricinin bilgisayarında çalışan testler için gerekli değildir.</p><p>Bugün birçok ekip testlerini GitHub Actions, GitLab CI veya Jenkins gibi CI/CD platformlarında çalıştırmaktadır.</p><p>CI/CD pipeline kavramını ve önemini daha detaylı incelemek isterseniz, <a href="https://medium.com/@islamoglu.cagla/but-it-works-on-my-machine-the-most-dangerous-phrase-in-software-teams-54041f9874bc?sharedUserId=islamoglu.cagla"><strong>bu makaleme</strong></a> göz atabilirsiniz.</p><p>Dolayısıyla pipeline’ın da aynı güvenlik kurallarına uyması gerekir.</p><p>Bu nedenle GitHub Actions içerisinde;</p><ul><li>SSH bilgileri GitHub Secrets içerisinde saklanır.</li><li>Pipeline çalışırken gerekli yapılandırma oluşturulur.</li><li>Framework bu bilgileri okuyarak SSH bağlantısını oluşturur.</li><li>Testler güvenli bağlantı üzerinden çalıştırılır.</li></ul><p>Yani GitHub Actions yalnızca testleri çalıştıran bir araç değildir. Aynı zamanda güvenli bağlantının kurulması için gerekli ortamı da hazırlar.</p><h3>Bu Makalede İnceleyeceğimiz Mimari</h3><p>Bu seri boyunca aşağıdaki mimariyi adım adım oluşturacağız.</p><pre>                  GitHub Secrets<br>                        │<br>                        ▼<br>                  GitHub Actions<br>                        │<br>                        ▼<br>             configuration.properties<br>                        │<br>                        ▼<br>              ConfigurationProperty<br>                        │<br>                        ▼<br>                 SshTunnelManager<br>                        │<br>                        ▼<br>                   JSch Session<br>                        │<br>                        ▼<br>                SSH Port Forwarding<br>                        │<br>                        ▼<br>                     JDBC Driver<br>                        │<br>                        ▼<br>                     PostgreSQL</pre><p>İlk bakışta karmaşık gibi görünse de aslında her bileşenin yalnızca tek bir sorumluluğu vardır.</p><ul><li><strong>GitHub Secrets</strong>, hassas bilgileri güvenli şekilde saklar.</li><li><strong>GitHub Actions</strong>, çalışma ortamını hazırlar.</li><li><strong>configuration.properties</strong>, ortam bağımsız yapılandırmayı sağlar.</li><li><strong>ConfigurationProperty</strong>, yapılandırma bilgilerini merkezi olarak yönetir.</li><li><strong>SshTunnelManager</strong>, SSH bağlantısını oluşturur.</li><li><strong>JDBC</strong>, oluşturulan güvenli tüneli kullanarak veritabanına erişir.</li></ul><p>Bu sorumlulukların birbirinden ayrılması framework’ün hem okunabilirliğini hem de sürdürülebilirliğini artırmaktadır.</p><h3>Sonuç</h3><p>SSH Tunnel yalnızca güvenliği artıran bir teknoloji değildir. Aynı zamanda test otomasyon framework’lerinin farklı ortamlarda aynı şekilde çalışabilmesini sağlayan önemli bir altyapı bileşenidir.</p><p>Bir sonraki bölümde geliştirici ve test mühendislerinin bu mimariyi kendi bilgisayarlarında nasıl kullandığını inceleyeceğiz. SSH erişiminin nasıl sağlandığını, yapılandırma dosyasının nasıl hazırlandığını ve framework’ün testler başlamadan önce SSH Tunnel bağlantısını nasıl yönettiğini adım adım ele alacağız.</p><p>Bu makalede anlatılan mimarinin örnek uygulamasını içeren açık kaynak test otomasyon projesi için, <a href="https://github.com/afet-yonetim-sistemi/ays-be-api-automation">Afet Yönetim Sistemi API Test Otomasyonu</a> <br>adresini ziyaret edebilirsiniz.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2551eefb832b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“But It Works on My Machine”: The Most Dangerous Phrase in Software Teams]]></title>
            <link>https://medium.com/@islamoglu.cagla/but-it-works-on-my-machine-the-most-dangerous-phrase-in-software-teams-54041f9874bc?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/54041f9874bc</guid>
            <category><![CDATA[reality]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Fri, 12 Jun 2026 13:52:56 GMT</pubDate>
            <atom:updated>2026-06-12T13:52:56.341Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t7VK3rQDnlzoxd0pFfRKZg.png" /></figure><p>As a Software Test Engineer, one of the most common responses I encounter when reporting a bug is:</p><blockquote><em>“I tested it. It works on my machine.”</em></blockquote><p>In some cases, this statement is even enough for a bug to be rejected or its priority to be lowered.</p><p>But is it really important that it works on a developer’s local environment?</p><p>Or is what truly matters whether it works in the environment where users will actually interact with it?</p><p>Years of experience across software teams have taught us one thing:</p><p><strong>Just because an application works locally does not mean it works correctly.</strong></p><h3>How Accurately Does a Local Environment Represent Reality?</h3><p>Over time, developers’ local environments become highly customized and comfortable.</p><p>A missing configuration may go unnoticed because it was set up months ago.</p><p>An environment variable may be required, but it already exists on the machine.</p><p>Test data may still be available and silently supporting application behavior.</p><p>Caches may be masking underlying issues.</p><p>Files may already exist in the expected locations.</p><p>In other words, a developer’s machine gradually adapts to the application.</p><p>User environments do not.</p><p>CI/CD environments do not.</p><p>Production environments do not.</p><p>That is why the phrase “it works on my machine” can sometimes be misleading.</p><h3>Why Do Test Engineers See Different Results?</h3><p>When a bug is reported, developers and testers appear to be working with the same application.</p><p>However, the conditions are often not identical.</p><p>A tester may be working in a different environment.</p><p>Different user roles may be involved.</p><p>The available data sets may vary.</p><p>Dependencies and integrated services may behave differently.</p><p>Sometimes the issue only appears under a specific combination of conditions.</p><p>For this reason, being unable to reproduce a bug does not necessarily mean that the bug does not exist.</p><p>It may simply mean that the right conditions have not yet been identified.</p><h3>Why Are CI/CD Pipelines So Important?</h3><p>Today, software teams rely on tools such as GitHub Actions, Jenkins, GitLab CI, and Azure DevOps.</p><p>While the tools may differ, the objective remains the same:</p><p>To validate code in a standardized and repeatable environment, not only on a developer’s machine.</p><p>This is where the true value of CI/CD becomes evident.</p><p>Running tests in clean environments helps teams:</p><ul><li>Identify hidden dependencies.</li><li>Detect environment-specific behavior.</li><li>Reveal missing configurations.</li><li>Verify whether tests are truly reliable and repeatable.</li></ul><p>Many critical issues become visible for the first time during CI pipeline executions.</p><p>This does not necessarily indicate a problem with the pipeline itself.</p><p>Rather, it often means the pipeline has exposed a problem that was previously hidden.</p><h3>“No Bug” Is Not the Same as “I Couldn’t Reproduce It”</h3><p>A common situation in software teams looks something like this:</p><p>A tester reports a bug.</p><p>A developer follows the same steps.</p><p>The issue cannot be reproduced.</p><p>The conclusion becomes:</p><blockquote><em>“There is no bug.”</em></blockquote><p>From a technical perspective, a more accurate statement would be:</p><blockquote><em>“I couldn’t reproduce the bug in my environment.”</em></blockquote><p>The difference between these two statements is significant.</p><p>The first assumes that the problem does not exist.</p><p>The second acknowledges that further investigation may be required.</p><p>Teams with a strong quality culture tend to embrace the second approach.</p><p>Because the goal is not to prove who is right.</p><p>The goal is to understand the problem.</p><h3>The Greatest Value of the Quality Process</h3><p>The purpose of software testing is not simply to find defects.</p><p>The purpose is to identify risks before they reach end users.</p><p>For that reason, when a bug report is received, the first question should not be:</p><blockquote><em>“Does it work on my machine?”</em></blockquote><p>The more valuable question is:</p><blockquote><em>“Under which conditions does this scenario fail?”</em></blockquote><p>Because users do not interact with the developer’s machine.</p><p>They interact with real-world environments.</p><p>And software quality is ultimately measured under those conditions.</p><h3>Conclusion</h3><p>“It works on my machine” is a phrase heard frequently throughout software development.</p><p>From a quality perspective, however, it should not be viewed as a conclusion.</p><p>It should be viewed as the beginning of an investigation.</p><p>To confidently say that a problem has been resolved, it must be validated not only in one environment, but across all relevant environments where the software is expected to operate.</p><p>Because successful software is not defined by running correctly on a developer’s machine.</p><p>It is defined by continuing to behave correctly when it reaches the people who actually use it.</p><h3>Finally</h3><p>If it only works on your machine, it doesn’t work — it’s just waiting.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=54041f9874bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Should the Senior–Junior Relationship Be? (And How It Should Not Be)]]></title>
            <link>https://medium.com/@islamoglu.cagla/how-should-the-senior-junior-relationship-be-and-how-it-should-not-be-706839dbdea3?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/706839dbdea3</guid>
            <category><![CDATA[communication-skills]]></category>
            <category><![CDATA[communication]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Fri, 27 Mar 2026 18:10:48 GMT</pubDate>
            <atom:updated>2026-03-27T18:10:48.937Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uPiwokmoAR-tejuktL00Cg.jpeg" /></figure><p>One of the most critical dynamics in software teams is the senior–junior relationship.</p><p>When this relationship is built correctly, the team moves faster, quality improves, and people grow.<br>When it is not, motivation drops, errors increase, and an invisible tension forms within the team.</p><p>So what is the right balance?</p><h3>How It Should Be</h3><h3>1. Should guide and provide direction</h3><p>Being a senior is not just about getting the job done.</p><p>Clearing the path for a junior, showing where to start, and providing direction when needed are essential parts of this role.</p><p>Even saying, “Start here, check this document, and let me know if you get stuck” can make a big difference.</p><h3>2. Should explain the reasoning, not just the result</h3><p>Showing how something is done is not enough.<br>It’s important to explain why it is done that way.</p><p>Because someone who understands the logic:</p><ul><li>Can solve new problems on their own</li><li>Does not repeat the same mistakes</li><li>Truly grows</li></ul><h3>3. Should be approachable</h3><p>A junior should not hesitate to ask questions.</p><p>Responses like “not now” or “we’ll look at it later” — when repeated constantly — eventually break communication.</p><p>You don’t have to be available all the time, but you do have to be approachable.</p><h3>4. Should build trust</h3><p>Instead of assuming a junior’s work is wrong from the start,<br>they should be given space to try.</p><p>Allowing mistakes is a key part of growth.</p><h3>5. Should teach while giving feedback</h3><p>Saying “this is wrong” is easy.</p><p>What really matters is:<br>“You can do this better like this.”</p><p>If feedback does not help the other person improve, it only wears them down.</p><h3>How It Should Not Be</h3><h3>1. A condescending attitude</h3><p>The “I know everything” mindset is one of the biggest breaking points within a team.</p><p>Knowledge is not for establishing superiority — it is for sharing.</p><h3>2. Superficial explanations</h3><p>Showing something briefly without explaining the details<br>is no different than not explaining it at all.</p><p>It’s not “Did you see it?”<br>It’s “Did you understand it?” that matters.</p><h3>3. Constant criticism without guidance</h3><p>A mindset that constantly finds faults but offers no solutions<br>eventually lowers motivation.</p><p>The junior knows what is wrong, but not how to fix it.</p><h3>4. Being inaccessible</h3><p>Constantly postponing or dismissing questions<br>leaves the junior on their own.</p><p>This often leads to:</p><ul><li>Wrong decisions</li><li>Inconsistent structures</li><li>Unnecessary repetition</li></ul><h3>5. Expecting perfection</h3><p>Expecting perfect results from someone who has not been properly guided is unrealistic.</p><p>Growth is a process, not a one-time outcome.</p><h3>Conclusion</h3><p>The senior–junior relationship is not a hierarchy, but a growth partnership.</p><p>One brings experience,<br>the other brings the willingness to learn.</p><p>When these two align, not only individuals grow,<br>but the entire team does.</p><p>Because great teams are not just made of people who write good code,<br>but of people who help each other grow.</p><p>Knowledge is power. But shared knowledge is real power.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=706839dbdea3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is Relying Only on the Analysis Enough When Testing a Brand-New Screen?]]></title>
            <link>https://medium.com/@islamoglu.cagla/is-relying-only-on-the-analysis-enough-when-testing-a-brand-new-screen-5142445c0dfe?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/5142445c0dfe</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[analysis]]></category>
            <category><![CDATA[test-planning]]></category>
            <category><![CDATA[logic]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Wed, 07 Jan 2026 17:55:25 GMT</pubDate>
            <atom:updated>2026-01-07T17:55:25.390Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oyzm_j4yofcHVdDtT9biOA.png" /></figure><p>When a newly developed screen lands in our hands, the first reflex in the testing process is usually clear:<br>Open the analysis, check the business rules, and verify the scenarios one by one.</p><p>Yes, analysis documents are the foundation of testing.<br>But it needs to be said clearly: <strong>analysis is not sacred</strong>.</p><p>If we truly want to test a screen with quality, we must learn to look not only at what is written, but also at what is <strong>not</strong> written.</p><h3>Analysis: A Guide, Not an Absolute Truth</h3><p>Analysis documents are created through the collective effort of product, business, and development teams. However, this does not mean they are flawless.</p><p>An analysis may contain:</p><ul><li>Missing business rules</li><li>Incorrect assumptions</li><li>Outdated information</li><li>Decisions that were “left as is” due to technical constraints</li></ul><p>The responsibility of a test engineer is not to apply these unquestioningly, but to pass them through a <strong>logical filter</strong>.</p><h3>“It’s Written in the Analysis” Does Not Finish the Test</h3><p>While testing a brand-new screen, the following sentence is particularly dangerous:</p><blockquote><em>“It works correctly because that’s how it’s written in the analysis.”</em></blockquote><p>A business rule may exist in the analysis, but these questions must always be asked:</p><ul><li>Does this rule make sense from a user’s perspective?</li><li>Does it have a real-world equivalent?</li><li>Is it consistent with other screens in the system?</li><li>What happens in edge cases?</li></ul><p>If the answers are not satisfactory, this is a <strong>test finding</strong>.</p><h3>The Test Engineer’s Strongest Tool: Logic</h3><p>Testing is not just about checking “right vs. wrong.”<br>Testing also measures whether the system <strong>makes sense</strong>.</p><p>Behavior that perfectly matches the analysis but fails logical reasoning can lead to:</p><ul><li>User errors</li><li>An increase in support requests</li><li>Problems that are difficult to roll back in production</li></ul><p>That’s where the test engineer must step in and ask:</p><blockquote><em>“Yes, it works — but should it really work this way?”</em></blockquote><h3>Opening a Bug Despite the Analysis Is Not Courage, It’s Responsibility</h3><p>Sometimes a bug report is opened for this reason:</p><blockquote><em>“It works according to the analysis, but it is problematic from a user perspective.”</em></blockquote><p>This is not about undermining the analysis.<br>On the contrary, it is about <strong>protecting the product</strong>.</p><p>A good test engineer:</p><ul><li>Knows the analysis</li><li>Understands the business rules</li><li>But can object when necessary</li></ul><p>Because testing does not defend the document — it defends the <strong>product itself</strong>.</p><h3>Questions You Should Ask Yourself When Testing a New Screen</h3><p>When testing a new screen, beyond the analysis, make sure to ask:</p><ul><li>How does a user feel when seeing this screen for the first time?</li><li>Does the system guide the user when incorrect data is entered?</li><li>What does the system do in unexpected scenarios?</li><li>How is this behavior handled on other screens?</li></ul><p>Most of these questions are not answered in the analysis.<br>But <strong>true quality starts here</strong>.</p><h3>Conclusion: Read the Analysis, Don’t Leave Your Logic at the Door</h3><p>Analysis is the starting point of the testing process — not the finish line.</p><p>When testing a brand-new screen:</p><ul><li>Follow the analysis</li><li>Verify the business rules</li><li>But never disable your logic</li></ul><p>Because sometimes the most critical defects are those that are<br> <strong>“aligned with the analysis, but wrong in reality.”</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5142445c0dfe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Network Tab: A Tester’s Magnifying Glass]]></title>
            <link>https://medium.com/@islamoglu.cagla/the-network-tab-a-testers-magnifying-glass-f5e002f0d429?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/f5e002f0d429</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[network-debugging]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Sat, 08 Nov 2025 18:22:11 GMT</pubDate>
            <atom:updated>2025-11-08T18:22:11.852Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ud_xnlfLZrIT_XCE2Gphjg.png" /></figure><p>For a tester, the <strong>Network tab</strong> is not just a collection of requests and responses — it’s a <strong>magnifying glass</strong> that reveals how well the frontend and backend communicate.</p><p>It’s the first place to look when you’re unsure:<br><em>“Is this issue frontend-related or backend-related?”</em></p><h3>🧩 Reading the Network Tab Correctly</h3><p>Each request tells a story — headers, payloads, response codes, and timing details. But the real skill lies in <strong>interpreting</strong> what you see.</p><p>When a request fails, don’t stop at “error 400” or “500.”<br> Ask <em>why</em> it happened.</p><ul><li>Was the request even supposed to reach the backend?</li><li>Did the frontend send the right payload?</li><li>Did the backend respond correctly but the UI fail to handle it?</li></ul><p>Understanding this flow helps you not only identify the problem but also know <strong>who to talk to</strong> — the frontend or backend developer — saving time and confusion in your team.</p><h3>⚙️ When Should the Frontend Make a Request?</h3><p>Not every user action deserves a trip to the backend.</p><p>The frontend should only make a backend request when:</p><ul><li><strong>The data needs to be validated or persisted</strong> on the server.</li><li><strong>The information isn’t already available</strong> in the current frontend context.</li><li><strong>A state change</strong> (like creating or updating data) must be reflected system-wide.</li></ul><p>Example:</p><pre>POST /api/user/create<br>Request body:<br>{<br>  &quot;name&quot;: &quot;John Doe&quot;,<br>  &quot;email&quot;: &quot;john@example.com&quot;<br>}<br><br>Response:<br>201 Created</pre><p>✅ Correct usage — the frontend is sending data that must exist in the backend.</p><h3>🚫 When the Frontend Should Not Send a Request</h3><p>The frontend <strong>should not</strong> send requests just to check things it can already handle.</p><p>For instance, when validating a form before submission:</p><ul><li>Empty fields,</li><li>Invalid email formats,</li><li>Name shorter than 2 characters,</li></ul><p>…these should all be handled <strong>on the frontend</strong> — no backend call needed.</p><p>Example of incorrect behavior:</p><pre>POST /api/user/create<br>Request body:<br>{<br>  &quot;name&quot;: &quot;&quot;,<br>  &quot;email&quot;: &quot;john@example.com&quot;<br>}<br><br>Response:<br>400 Bad Request<br>{<br>  &quot;message&quot;: &quot;Name must not be blank.&quot;<br>}</pre><p>In this case, the frontend offloads validation to the backend — but it shouldn’t.<br> This kind of unnecessary call adds server load and delays user feedback.</p><p>✅ <strong>Better approach:</strong><br> Frontend checks this locally and shows an instant validation message without a request.</p><h3>🧠 The Power of Correct Interpretation</h3><p>The Network tab doesn’t just display logs — it reveals the <strong>quality of communication</strong> between the frontend and backend.</p><p>When you interpret it correctly as a tester:</p><ul><li>You identify root causes faster,</li><li>Detect unnecessary backend calls,</li><li>Contribute to better performance and UX,</li><li>And most importantly — you know <strong>exactly who to talk to</strong> in your team.</li></ul><p>A tester’s magnifying glass is the Network tab, but seeing clearly starts with reading it right.🔍</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5e002f0d429" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Manual API Testing with Postman: Critical Checks and Real-World Scenarios]]></title>
            <link>https://medium.com/@islamoglu.cagla/manual-api-testing-with-postman-critical-checks-and-real-world-scenarios-de615ab89891?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/de615ab89891</guid>
            <category><![CDATA[manual-testing]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[api-testing]]></category>
            <category><![CDATA[postman]]></category>
            <category><![CDATA[learning-and-development]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Mon, 21 Apr 2025 15:13:22 GMT</pubDate>
            <atom:updated>2025-04-21T15:13:22.046Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/860/1*RJaHCI8lNKKhTxu7lWdcag.jpeg" /></figure><p>When we think of API testing, we often picture a simple “send a request, get a response” scenario. But when manual testing comes into play, it’s not just about checking if we get the correct response. Especially when using a tool like Postman, which is both user-friendly and allows for detailed testing, we need to dig a bit deeper.<br>Postman is one of the most popular tools for API testing because it’s easy to use yet allows for comprehensive testing even without writing scripts. Before diving into automation, these manual tests can give us a solid understanding of the API’s robustness. So, what should we focus on when manually testing an API? Let’s go through it step by step. 🔍</p><p><strong>1- HTTP Method Check</strong><br>One of the most basic tests is to verify that an endpoint works with the correct HTTP methods. For example, a GET /users endpoint designed to retrieve data should not accept POST or DELETE methods.<br>🧪<strong>Scenario:</strong><br>If a DELETE /users request is accepted and returns a successful response, it indicates a serious security or authorization vulnerability. In such cases, developers should be notified. ⚠️</p><p><strong>2- Status Code Validation</strong><br>The correct status codes are crucial for both user experience and error handling. Incorrect status codes can either hide issues or mislead the user.<br>🧪<strong>Scenario:</strong><br>When a required field is missing (for example, an empty username), the API should return a 400 Bad Request. But if it returns a 500 Internal Server Error instead, it indicates that the error is not handled properly, and the system may be failing unexpectedly.</p><pre>// Sent request<br>{<br>  &quot;username&quot;: &quot;&quot;,<br>  &quot;email&quot;: &quot;user@example.com&quot;<br>}<br><br>// Expected response<br>{<br>  &quot;error&quot;: &quot;Username must not be blank&quot;<br>}<br>// HTTP Status: 400 Bad Request</pre><p>If the system returns a 500 instead, it signals that the error is being mishandled, as a user error is causing a system crash. 🚨</p><p><strong>3- Data Type Validation</strong><br>It’s important to check whether an API properly handles data types. Are the fields coming back in the expected format? What happens if you send a string to a field that expects a number?<br>🧪<strong>Scenario:</strong><br>If you send “abc” instead of an integer for a GET /users/{id} request, the system should return a 400 Bad Request. If it accepts the value or returns a 200 OK with empty data, it indicates missing data type validation.</p><p><strong>4- Validation Checks</strong><br>Backend validations play a key role in preventing issues that may slip past the frontend. Required fields must be checked, character limits must be enforced, and special characters should be filtered.<br>🧪<strong>Scenario:</strong><br>For a user creation API, if the following body is sent:</p><pre>{<br>  &quot;name&quot;: &quot;&quot;,<br>  &quot;email&quot;: &quot;not-an-email&quot;<br>}</pre><p>The system should respond with:</p><pre>{<br>  &quot;errors&quot;: {<br>    &quot;name&quot;: &quot;must not be blank&quot;,<br>    &quot;email&quot;: &quot;must be a valid email address&quot;<br>  }<br>}<br>// HTTP Status: 400 Bad Request</pre><p>If the system returns a 200 OK or 201 Created instead, there is a validation issue. 🚫</p><p><strong>5- Request and Response Structure</strong><br>In addition to sending the correct requests, we must also check if the responses are in the expected format and contain the expected data. Missing fields, extra data, or inconsistent data types should be flagged during testing.<br>🧪<strong>Scenario:</strong><br>If the expected response for a GET /products call is:</p><pre>{<br>  &quot;id&quot;: 12,<br>  &quot;name&quot;: &quot;Wireless Mouse&quot;,<br>  &quot;price&quot;: 199.99,<br>  &quot;currency&quot;: &quot;TRY&quot;<br>}</pre><p>But price is missing or currency is null, it points to a backend mapping issue or incomplete data validation. ⚠️</p><p><strong>6- Header Checks</strong><br>Headers play a critical role in both security and functionality of APIs. Especially headers like Authorization and Content-Type define how data is processed and what access is allowed. Therefore, it’s important to focus on these during testing.<br>🧪<strong>Scenario:</strong><br>If an API is designed to accept only requests with Content-Type: application/json, it should reject any request with Content-Type: text/plain. For example:</p><pre>POST /users HTTP/1.1<br>Content-Type: text/plain<br><br>{<br>  &quot;name&quot;: &quot;Çağla&quot;,<br>  &quot;email&quot;: &quot;cagla@example.com&quot;<br>}</pre><p>The response should be:</p><pre>{<br>  &quot;error&quot;: &quot;Unsupported Media Type&quot;<br>}<br>// HTTP Status: 415 Unsupported Media Type</pre><p>If the API accepts this request and returns a 200 OK or 201 Created, it signals an issue in handling invalid data formats. This can lead to security risks and data integrity issues. ⚠️</p><p><strong>7- Error Message Management</strong><br>API error messages should clearly communicate what went wrong, without exposing system internals.<br>🧪<strong>Scenario:</strong><br>If a server-side error occurs, instead of returning a technical stack trace like “NullPointerException at line 54”, the system should return:</p><pre>{<br>  &quot;error&quot;: &quot;An unexpected error occurred. Please contact support.&quot;<br>}<br>// HTTP Status: 500 Internal Server Error</pre><p>This helps prevent revealing sensitive system details to end-users. 🔒</p><p><strong>8- Empty Data and Edge Case Testing</strong><br>While things may work smoothly under normal conditions, it’s essential to test how the system behaves in edge cases.<br> • Does the system return valid results for empty queries?<br> • Are the character limits properly enforced?<br> • Are edge cases like 255-character input handled correctly?<br>🧪<strong>Scenario:</strong><br>For a GET /search?query=asdf request that returns no results, the system should return a 200 OK with an empty array. If a 500 Internal Server Error is returned, it indicates poor error handling. ⚠️</p><p><strong>9- Database Impact and Side Effects</strong><br>It’s not just about returning the correct response, but also about whether the API has the intended effect in the background. Is data being written to the database correctly? Can duplicate records be added?<br>🧪<strong>Scenario:</strong><br>If you make two identical POST /users requests, the system should return a 409 Conflict for the second request, preventing duplicate records. If it returns 201 Created, there is a risk of duplicate entries. ⚠️</p><p><strong>10- Authorization and Access Controls</strong><br>Not every user can access every endpoint. Therefore, role-based access controls must be tested.<br>🧪<strong>Scenario:</strong><br>For an admin panel endpoint, a regular user’s token should be denied access with a 403 Forbidden response.</p><p><strong>11- Rate Limiting and Too Many Requests (429)</strong><br>For critical operations, the system should limit excessive requests within a short time.<br>🧪<strong>Scenario:</strong><br>If the same IP makes 100 POST /login requests within 5 seconds, the system should return a 429 Too Many Requests. If it doesn’t, the system becomes vulnerable to brute-force attacks. 🔐</p><p><strong>Conclusion</strong><br>Manual API testing is not just about verifying if an endpoint works; it’s about understanding the security, validation, data handling, and error management mechanisms of the system. Postman is more than just a tool for sending requests — it’s a magnifying glass that helps you spot even the smallest details.<br>A well-tested API is not only bug-free but also secure, understandable, and user-friendly. 🌟</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de615ab89891" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Test Engineers: Not Delaying the Process, but Improving Quality]]></title>
            <link>https://medium.com/@islamoglu.cagla/test-engineers-not-delaying-the-process-but-improving-quality-942c5f0aaa6a?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/942c5f0aaa6a</guid>
            <category><![CDATA[mobbing]]></category>
            <category><![CDATA[software-test-engineer]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Sat, 16 Nov 2024 11:21:31 GMT</pubDate>
            <atom:updated>2024-11-16T11:21:31.729Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uCD3vF9bkabg0ZzOsGNVfA.jpeg" /></figure><p>If you work as a software test engineer, you’ve probably heard these statements:</p><ul><li>“Testers always slow down the process.”</li><li>“They keep causing unnecessary problems.”</li><li>“You found a bug? Then suggest a fix too!”</li></ul><p>At first glance, these might sound like jokes, but they reflect a common perception: that test engineers unnecessarily prolong the process or “get stuck in the details” and hinder progress. However, this perception overlooks how critical testing is in software development.</p><p><strong>Detail-Oriented? Yes, and for a Reason!</strong><br>As test engineers, there’s a reason we focus on the details: details reveal the weakest links in a system. Our job is to uncover cracks in an application that might otherwise go unnoticed. Overlooking even a small detail today could lead to a terrible user experience or a major security flaw tomorrow.</p><p>Unfortunately, “focusing on the details” is often interpreted as “losing sight of the big picture.” In reality, it’s quite the opposite. We work to ensure the system’s global success. If small problems aren’t addressed today, they could become large-scale disasters tomorrow.</p><p><strong>“You Found a Bug? Then Fix It!”</strong><br>This is another statement we often encounter. When we report a bug, developers or managers sometimes expect us to propose a solution as well. But our responsibility is to identify the issue and point the team in the right direction.</p><p>Everyone contributes their expertise in their respective areas. We focus on revealing issues and providing insights on how they impact the system. A test engineer reporting a bug is not creating extra work; they’re providing guidance. Think of it this way: ignoring a test engineer’s warning about a system flaw is like ignoring an engineer’s safety warning while constructing a building.</p><p><strong>How Test Engineers Are Perceived</strong><br>Sadly, test engineers are often perceived as playing a “negative” role in the team.</p><ul><li>People think we slow the process because resolving the issues we find takes time.</li><li>They think we complicate matters because we focus on the details.</li></ul><p>The truth is:</p><ul><li><strong>We’re not slowing things down; we’re saving the system.</strong> Ignoring a bug today could lead to significantly higher costs tomorrow.</li><li><strong>We’re not making things complicated; we’re ensuring robustness.</strong> Complexity arises when overlooked problems pile up over time.</li></ul><p><strong>The Value of Test Engineers</strong><br>In software development, test engineers are not just people who find bugs. We are:</p><ul><li><strong>Risk reducers,</strong></li><li><strong>User experience enhancers,</strong></li><li><strong>Advocates for system reliability.</strong></li></ul><p>When test engineers are given the necessary space and respect in the process, the quality of the software improves significantly. Testing should be seen not as a barrier but as an investment in the product’s success.</p><p><strong>Final Thoughts:</strong><br>As test engineers, we need to continue explaining that we’re not here to delay the process; we’re here to improve the quality of the system. This article aims to help break that misconception. At the end of the day, we’re all working toward producing a high-quality product. Instead of discouraging one another with mobbing, let’s focus on acknowledging and appreciating each other’s efforts. Encouraging one another is far more valuable than tearing each other down.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=942c5f0aaa6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tackling Cybersecurity Threats: The Story Behind Our AWS-Based Project]]></title>
            <link>https://medium.com/@islamoglu.cagla/tackling-cybersecurity-threats-the-story-behind-our-aws-based-project-f7e6b5518f18?source=rss-1b555f4a39fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/f7e6b5518f18</guid>
            <category><![CDATA[lambda-function]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ec2]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Çağla İslamoğlu]]></dc:creator>
            <pubDate>Thu, 29 Aug 2024 14:23:16 GMT</pubDate>
            <atom:updated>2024-08-29T14:23:16.246Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*mi5_2eAm9hesM4jTiyhgog.png" /></figure><p>In recent years, cybersecurity threats have become increasingly sophisticated and dangerous. Critical infrastructures and large-scale systems are constantly under attack, making robust and flexible solutions a necessity. With this need in mind, we decided to develop a project using AWS tools. In this article, I’ll share the story of this project, the challenges we faced, and the successes we achieved.</p><p>Any device connected to the internet is a potential target. Recent DDoS attacks, data breaches, and ransomware incidents have once again highlighted how serious these threats can be. Specifically, attacks like SSH login attempts pose a significant risk to system security, making it crucial to develop a strong defense mechanism.</p><p>We asked ourselves: if we were system administrators facing these threats, how would we detect attacks and respond quickly? This question led us to develop a project aimed at detecting security events and responding immediately, leveraging AWS’s powerful and scalable services.</p><p><strong>The Structure of Our Project:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iVJsrVpKX26m8bMpOcXy7A.png" /></figure><p>As we started the project, we first set up a central instance, where we installed Elasticsearch and Kibana. Our goal was to collect and analyze logs from instances located in different AWS regions. Additionally, we deliberately left certain ports open on these instances to attract potential attacks, allowing us to test our system’s response.</p><p>In this project, we used the following AWS services:</p><ul><li><strong>Lambda:</strong> To process logs and take necessary actions.</li><li><strong>EC2:</strong> Instances left open to attacks in different regions.</li><li><strong>SQS:</strong> To transport logs and events.</li><li><strong>EventBridge:</strong> To route events and trigger automated workflows.</li><li><strong>Step Functions:</strong> To orchestrate different Lambda functions and create workflows.</li><li><strong>SES:</strong> To send email notifications to the security team when a security event was detected.</li><li><strong>Elasticsearch &amp; Kibana:</strong> To visualize and analyze logs.</li></ul><p><strong>How It Worked:</strong></p><p>In our project, logs from different regions were routed to specific Lambda functions via EventBridge. These functions analyzed the logs, identified security events, and flagged malicious IP addresses. The identified IP addresses were automatically added as rules to the application firewall. Moreover, whenever suspicious activities were detected, the relevant security teams were immediately notified via SES. This approach allowed us to establish a quick and effective defense mechanism against cyber attacks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*-qXd_5LHK1aMsZZCTZhs4A.png" /></figure><p><strong>Conclusion:</strong></p><p>Through this project, we once again realized how powerful and flexible the tools provided by AWS are. The challenges we encountered in the world of cybersecurity pushed us to come up with more creative solutions. Thanks to AWS’s scalability and flexibility, we were able to develop a solid defense mechanism against these types of attacks.</p><p><strong>Final Thoughts:</strong></p><p>Cybersecurity is an area that should never be taken lightly. The lessons we learned during this project will guide us in building even more secure systems in the future. In the face of cyber threats, we must continuously develop new strategies to stay strong. If you’re thinking of developing a project in the field of cybersecurity, I highly recommend trying out the tools AWS has to offer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f7e6b5518f18" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>