<?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 Murat Feyzioğlu on Medium]]></title>
        <description><![CDATA[Stories by Murat Feyzioğlu on Medium]]></description>
        <link>https://medium.com/@muratfeyzioglu?source=rss-aa2ff3f6558e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fM5YecMrS14Xuf49V013Pg.jpeg</url>
            <title>Stories by Murat Feyzioğlu on Medium</title>
            <link>https://medium.com/@muratfeyzioglu?source=rss-aa2ff3f6558e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 22:16:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@muratfeyzioglu/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[Pytest: Use Console values with “conftest.py”]]></title>
            <link>https://medium.com/beyn-technology/pytest-use-console-values-with-conftest-py-5284615b73f6?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/5284615b73f6</guid>
            <category><![CDATA[contests]]></category>
            <category><![CDATA[selenium-test-automation]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[pytest]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Wed, 29 Nov 2023 13:34:34 GMT</pubDate>
            <atom:updated>2023-11-29T13:34:34.387Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*5zx4ZlOvRqXRxrwg.png" /></figure><p>In the realm of software testing having an efficient testing suite is crucial to ensure the quality of your software applications. Pytest, an used testing framework, in the Python ecosystem has established itself as a reliable tool for creating and running tests. However, within Pytest there is a treasure called the conftest.py file. It is an asset that is often overlooked but can significantly transform your approach to test automation.</p><p>Whether you are a Quality Assurance Test Engineer, developer, or anyone involved in the testing process understanding and harnessing the potential of conftest.py can greatly enhance your testing workflow. This document aims to demystify the conftest.py file by exploring its capabilities and demonstrating how it can be leveraged to optimize your testing suite.</p><p>Together we will embark on a journey through the world of conftest.py. We will unravel its mysteries. Showcase its applications. From configuration management to fixture generation from customizing fixture behavior to integrating with third-party plugins and automating testing, in your CI/CD pipeline — conftest.py offers versatility that becomes invaluable once you comprehend its true potential. It can become your trusted ally in pursuit of top-notch software quality.<br>Whether you have been using Pytest for a while or are new, to the world of software testing this guide is here to help you make the most out of conftest.py. So let’s jump in and explore how we can utilize this tool to improve our testing efforts.</p><h3>How to Create and Use?</h3><p>Select or create a Directory. You should place your “conftest.py” file in the corresponding field of the test classes you intend to use. The “conftest.py” file applies to all test files within its own subdirectories. I choose “testCases” directory.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/397/1*fMwDG4t8UZFimCg-YnIzmw.png" /></figure><p>Inside the conftest.py file, you can define fixtures using the @pytest.fixture decorator. For example:</p><pre>import pytest<br><br>@pytest.fixture<br>def my_fixture():<br>    # Fixture setup code here<br>    yield<br>    # Fixture teardown code here (optional)</pre><p>This example defines a fixture named my_fixture. You can include setup and teardown code as needed within the fixture. You can also include other configurations or settings in the conftest.py file. For example, you are setting global test parameters, configuring logging, or defining hooks.</p><p>I want to show you an example. You can use this example exactly. In the example, there will be configuring logging, and defining hooks. This code gives that you can choose your explorer with your parameter afteryou can change as regarding your project.</p><pre>import pytest<br><br>from selenium import webdriver<br>from selenium.webdriver.chrome.service import Service as ChromeService<br><br><br>@pytest.fixture()<br>def setup(browser):<br>    if browser == &quot;firefox&quot;:<br>        driver = webdriver.Firefox()<br>        print(&quot;Launching Chrome browser&quot;)<br>        return driver<br>    elif browser == &quot;edge&quot;:<br>        driver = webdriver.Edge()<br>        print(&quot;Launching Firefox browser&quot;)<br>        return driver<br># if the user doesn&#39;t give any parameter.<br>    else:<br><br>        CHROMEDRIVER_PATH = &#39;C:/Users/Name/Desktop/chromedriver-win64/chromedriver.exe&#39;<br>        service = ChromeService(executable_path=CHROMEDRIVER_PATH)<br>        options = webdriver.ChromeOptions()<br>        driver = webdriver.Chrome(service=service, options=options)<br>        return driver<br><br># hooks, terminal info,<br># get the value from CLI/hooks<br>def pytest_addoption(parser):<br>    parser.addoption(&quot;--browser&quot;)<br><br># return the Browser value to setup method<br>@pytest.fixture()<br>def browser(request):<br>    return request.config.getoption(&quot;--browser&quot;)</pre><p>I added some comment lines for these functions but i would to explain some important parts.</p><pre>def pytest_addoption(parser):<br>    parser.addoption(&quot;--browser&quot;)</pre><p><strong>pytest_addoptions(parser):</strong></p><p>When you use this method, you can add an option on your console line. The pytest sees the “ — browser” option and it waits for a parameter after this.</p><p>— browser chrome</p><p>— browser edge etc.</p><pre>@pytest.fixture()<br>def browser(request):<br>    return request.config.getoption(&quot;--browser&quot;)</pre><p><strong>browser(request):</strong></p><p>This method takes your option from the console and returns.</p><p>chrome, edge, etc.</p><p>The main method is “<em>def setup(browser)</em>”. You need to define your fixture to your test method. As you see the method waits a parameter “browser”. browser(request) method gives the option to this parameter.</p><pre>def test_login(self, setup):</pre><p>Now you can use driver on your test method. There is a simple example. You will see there is no difference from the normal way to use “driver”. (<em>My chrome driver is a little bit different. That’s why i am using some different libraries and third party plugins</em>. )</p><pre>    def test_login(self, setup):<br>        self.driver = setup<br><br>        self.driver.get(self.baseURL)<br><br>        self.login_page = LoginPage(self.driver)<br>        print(self.driver)<br><br>        self.login_page.setUserName(self.username)<br>        print(self.driver)<br>        self.login_page.setPassword(self.password)<br>        self.login_page.clickLogin()<br>        act_title = self.driver.title<br><br>        if act_title == &quot;Dashboard / nopCommerce administration&quot;:<br>            assert True<br>        else:<br>            assert False<br><br>        self.driver.close()</pre><p>You can give a parameter from the console before the test run. And your driver is preparedaccording your parameter.</p><p>“pytest -v -s testCases/test_login.py <strong>— browser chrome</strong>”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/890/1*xA4MAVKcv9otrLoRriMrng.png" /></figure><p>First example, take a parameter from the console. It was a great feature. Now I want to show you how that add information to the console. It will be more useful if you use this feature.</p><p>For example, we have many engineers, project modules, etc and we want to separate or cluster. You can add information with “conftest.py”. These informations are readable from third-party pluggins. This is the biggest differences from the logs.</p><p>We are going to add this information with key and value.</p><pre>def pytest_configure(config):<br>    config._metadata[&#39;Project Name&#39;] = &#39;nop Commerce&#39;<br>    config._metadata[&#39;Module Name&#39;] = &#39;Customers&#39;<br>    config._metadata[&#39;Tester&#39;] = &#39;Murat_test&#39;</pre><p>when the conftest.py is worked, this method will be triggered. You can add what you want below your console lines.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*BHjzzozjwtgjauUrwTG-Dw.png" /></figure><p>I hope these two exapmles will improve your automation. You will add information to the console and you will take parameters from the console. Don’t underestimatethe power of using a console. Your outputs and inputs will become more professional.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5284615b73f6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/pytest-use-console-values-with-conftest-py-5284615b73f6">Pytest: Use Console values with “conftest.py”</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Advanced Techniques for API Testing with Pytest]]></title>
            <link>https://medium.com/beyn-technology/advanced-techniques-for-api-testing-with-pytest-f85a4376ae0?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f85a4376ae0</guid>
            <category><![CDATA[test]]></category>
            <category><![CDATA[pytest]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[api-test-automation]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Wed, 01 Mar 2023 06:21:32 GMT</pubDate>
            <atom:updated>2023-03-01T06:21:32.290Z</atom:updated>
            <content:encoded><![CDATA[<p>API testing is a critical aspect of software development and plays an essential role in ensuring the reliability and stability of web applications. Pytest is one of the most popular testing frameworks in the Python community and is widely used for API testing. In this article, we will discuss some advanced techniques for API testing with Pytest.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*PFTz7G2eL0JgZm5xQgstyg.png" /></figure><h3>Parameterization</h3><p>Pytest provides a powerful feature called parameterization that allows you to run the same test with different inputs. This is particularly useful when testing APIs that require different input parameters. To use parameterization in Pytest, you can use the <em>@pytest.mark.parametrize</em> decorator. For example, consider the following test function that tests a <em>GET</em> request with different query parameters:</p><pre>import pytest<br>import requests<br><br>@pytest.mark.parametrize(&quot;param1, param2&quot;, [(&quot;value1&quot;, &quot;value2&quot;), (&quot;value3&quot;, &quot;value4&quot;)])<br>def test_api_call_with_different_params(param1, param2):<br>    url = &quot;https://example.com/api&quot;<br>    params = {&quot;param1&quot;: param1, &quot;param2&quot;: param2}<br>    response = requests.get(url, params=params)<br>    assert response.status_code == 200</pre><h4>Why do we use parameterization?</h4><p>It is a technique used in testing to run the same test with different inputs or parameters. There are several reasons why parameterization is useful in testing:</p><ol><li><strong>DRY principle</strong>: It helps you follow the “Don’t Repeat Yourself” (DRY) principle. Instead of duplicating the same test code with different inputs, you can create a single test function that accepts multiple inputs.</li><li><strong>Code readability:</strong> It can improve code readability by allowing you to define test cases clearly and concisely. You can use descriptive names for the parameters and test cases, which makes it easier to understand what the test is doing.</li><li><strong>Code maintainability</strong>: It makes it easier to maintain test code. If you need to add or modify test cases, you only need to modify the parameter values, not the test code itself.</li><li><strong>Test coverage:</strong> It can help you increase test coverage by allowing you to test a function with a wide range of inputs. This helps you catch edge cases and ensures that your function works correctly in all scenarios.</li></ol><p>Overall, it is a powerful technique that can help you write more efficient, maintainable, and expressive tests. By using parameterized tests, you can thoroughly test your code and catch more bugs while reducing the amount of test code you need to write and maintain.</p><h3>Fixtures</h3><p>Fixtures are reusable functions that can set up test data or environments for your test cases. Pytest allows you to define fixtures with the <em>@pytest.fixture </em>decorator. Fixtures can be used to set up authentication, database connections, or mock objects. Here’s an example of a fixture that sets up a session with an authenticated API:</p><pre>import pytest<br>import requests<br><br>@pytest.fixture(scope=&quot;session&quot;)<br>def api_session():<br>    url = &quot;https://example.com/api/login&quot;<br>    data = {&quot;username&quot;: &quot;myuser&quot;, &quot;password&quot;: &quot;mypassword&quot;}<br>    response = requests.post(url, data=data)<br>    assert response.status_code == 200<br>    session = requests.Session()<br>    session.headers.update({&quot;Authorization&quot;: f&quot;Bearer {response.json()[&#39;access_token&#39;]}&quot;})<br>    yield session</pre><p>You can then use the fixture in your test functions by passing it as an argument. For example:</p><pre>def test_api_call_with_authenticated_session(api_session):<br>    url = &quot;https://example.com/api/data&quot;<br>    response = api_session.get(url)<br>    assert response.status_code == 200</pre><h4>Why do we use fixtures?</h4><p>Fixtures are a powerful feature in Pytest that allow you to define reusable objects and code that can be used in multiple tests. There are several reasons why fixtures are useful in testing:</p><ol><li><strong>DRY principle:</strong> Fixtures help you follow the “Don’t Repeat Yourself” (DRY) principle. Instead of duplicating the same setup code in multiple tests, you can define a fixture that encapsulates the setup code and reuse it across multiple tests.</li><li><strong>Code readability:</strong> Fixtures can improve code readability by allowing you to separate the setup code from the test code. This makes it easier to understand what the test is doing and how it is being set up.</li><li><strong>Code maintainability:</strong> Fixtures make it easier to maintain test code. If you need to change the setup code, you only need to modify the fixture code, not the test code itself.</li><li><strong>Test isolation:</strong> Fixtures can help you isolate tests by ensuring that each test runs in a clean and consistent environment. This can help you avoid side effects and ensure that each test is independent of the others.</li><li><strong>Test performance:</strong> Fixtures can improve test performance by allowing you to reuse expensive resources across multiple tests. For example, you can use a fixture to set up a database connection and reuse it across multiple tests, rather than setting up a new connection for each test.</li></ol><p>Overall, fixtures are a powerful tool for improving the efficiency, maintainability, and readability of your tests. By using fixtures, you can avoid code duplication, improve test isolation, and reduce the amount of setup code you need to write and maintain. This makes it easier to write and maintain high-quality tests that catch bugs and ensure the reliability and stability of your code.</p><h3>Custom assertions</h3><p>Pytest allows you to write custom assertion functions that can make your tests more expressive and easier to read. Custom assertions can encapsulate complex logic or calculations that are required to check the correctness of an API response. For example:</p><pre>import pytest<br>import requests<br><br>def assert_status_code(response, expected_code):<br>    assert response.status_code == expected_code, f&quot;Expected {expected_code}, but got {response.status_code}&quot;<br><br>def test_api_call_with_custom_assertion():<br>    url = &quot;https://example.com/api/data&quot;<br>    response = requests.get(url)<br>    assert_status_code(response, 200)</pre><ol><li><strong>Improved readability:</strong> Custom assertions can improve the readability of your code by allowing you to use more descriptive and intuitive assertions. For example, you can define an assertion function called assert_status_code that checks the status code of an API response, rather than using the built-in assert function with a complex expression.</li><li><strong>Reusability:</strong> Custom assertions can be reused across multiple tests and even across multiple projects. This can help you avoid duplicating assertion code and improve the maintainability of your tests.</li><li><strong>Reduced test code:</strong> Custom assertions can help you reduce the amount of test code you need to write by encapsulating complex or repetitive assertion logic into a single function. This can make your tests easier to read, write, and maintain.</li><li><strong>Improved error reporting:</strong> Custom assertions can help you improve the error reporting of your tests by providing more detailed and informative error messages. This can help you diagnose and fix problems more quickly and efficiently.</li></ol><p>To define a custom assertion function in Pytest, you can use the assert statement and raise an AssertionError if the condition is not met. For example, here is a custom assertion function that checks the length of a list:</p><pre>def assert_list_length(list_to_check, expected_length):<br>    assert len(list_to_check) == expected_length, f&quot;List length was {len(list_to_check)}, expected {expected_length}&quot;</pre><p>You can then use this function in your tests like any other assertion function:</p><pre>def test_my_list():<br>    my_list = [1, 2, 3, 4]<br>    assert_list_length(my_list, 4)</pre><p>Overall, custom assertions are a powerful tool for improving the readability, reusability, and maintainability of your tests. By using custom assertions, you can write tests that are more expressive, efficient, and informative, and catch more bugs in your code.</p><h3>Using Plugins</h3><p>Pytest provides a large ecosystem of plugins that can extend the functionality of the framework. There are many plugins available for API testing, such as pytest-bdd, which allows you to write API tests in a behavior-driven development (BDD) style, and pytest-httpx, which provides a faster and more efficient HTTP client than the standard requests library. To use a plugin, you can install it using pip and then add it to your pytest configuration file.</p><p>Plugins are a fundamental part of the Pytest ecosystem, and they play a significant role in extending the functionality of the framework. Pytest provides a large number of plugins that can help you to write more efficient, maintainable, and expressive tests. In this article, we will dive deep into using plugins with Pytest.</p><p><strong>Installing plugins:</strong> Pytest plugins can be installed via pip, just like any other Python package. For example, to install the pytest-html plugin, you can run:</p><pre>pip install pytest-html</pre><p>This will install the pytest-html package and make it available to your Pytest tests. Some plugins may have additional requirements or dependencies, so be sure to check the plugin&#39;s documentation for installation instructions.</p><p><strong>Activating plugins:</strong> Once you’ve installed a plugin, you need to activate it for your Pytest tests. You can activate plugins in several ways:</p><ul><li><strong>Command-line options:</strong> Pytest provides several command-line options that allow you to activate plugins. For example, to activate the pytest-html plugin and generate an HTML report of your test results, you can run:</li></ul><pre>pytest --html=report.html</pre><p>This will activate the pytest-html plugin and instruct it to generate an HTML report of your test results.</p><ul><li><strong>Configuration files:</strong> Pytest also allows you to configure plugins in a configuration file. You can create a file named pytest.ini in the root directory of your project and add a pytest_plugins section. For example, to activate the pytest-html plugin, you can add the following to your pytest.ini file:</li></ul><pre>[pytest]<br>addopts = --html=report.html</pre><p>This will activate the pytest-html plugin and instruct it to generate an HTML report of your test results.</p><ul><li><strong>Decorators:</strong> Some plugins can be activated by applying a decorator to a test function or fixture. For example, the pytest.mark.xfail decorator can be used to mark a test as expected to fail. To use this decorator, you can add the following to your test function:</li></ul><pre>import pytest<br>@pytest.mark.xfail<br>def test_something():<br>    assert False</pre><p>This will activate the pytest.mark.xfail plugin and mark the test as expected to fail.</p><p>In conclusion, Pytest provides many advanced features for API testing that can help you write more maintainable, expressive, and efficient tests. Parameterization, fixtures, custom assertions, and plugins are just a few examples of how Pytest can be used to create powerful and flexible test suites for your APIs.</p><h3>Why do we need to use the advantages techniques?</h3><p>The techniques for API testing with Pytest can be used to improve the quality and reliability of your tests. These techniques can help you test your API more thoroughly, catch more bugs, and ensure that your API works correctly in all scenarios.</p><p>Here are some reasons why you might want to use advanced techniques for API testing with Pytest:</p><h4><strong>Test Coverage</strong></h4><p>Advanced techniques can help you increase test coverage by allowing you to test your API with a wide range of inputs and scenarios. This can help you catch edge cases and ensure that your API works correctly in all scenarios.</p><h4><strong>Test Efficiency</strong></h4><p>Advanced techniques can help you write more efficient tests by allowing you to reuse code and resources across multiple tests. For example, you can use fixtures to set up a database connection and reuse it across multiple tests, rather than setting up a new connection for each test.</p><h4><strong>Test Organization</strong></h4><p>Advanced techniques can help you organize your tests in a way that makes it easier to read and maintain your code. For example, you can use markers to group your tests by functionality or importance.</p><h4><strong>Test Data Management</strong></h4><p>Advanced techniques can help you manage test data more efficiently. For example, you can use data factories to generate test data or mock objects to simulate external dependencies.</p><h4><strong>Test Reporting</strong></h4><p>Advanced techniques can help you generate more informative test reports that make it easier to understand the results of your tests. For example, you can use plugins to generate HTML reports or export test results to other formats.</p><p>The advanced techniques for API testing with Pytest can help you write better tests that are more thorough, efficient, and maintainable. By using these techniques, you can catch more bugs, improve the reliability of your API, and ensure that your code meets the highest standards of quality and reliability.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f85a4376ae0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/advanced-techniques-for-api-testing-with-pytest-f85a4376ae0">Advanced Techniques for API Testing with Pytest</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Test Strategy Process(TDD&BDD)]]></title>
            <link>https://medium.com/beyn-technology/test-strategy-process-tdd-bdd-42ff5ae223cf?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/42ff5ae223cf</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[bdd]]></category>
            <category><![CDATA[test-strategy]]></category>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Thu, 26 Jan 2023 06:04:34 GMT</pubDate>
            <atom:updated>2023-01-26T06:04:34.651Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, we will examine the importance and advantages of testing strategies. We will see how important choosing a testing strategy is for a project. And we’ll go into the details of the two big test strategies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*D0tA7W2kyJP5mUTaKOkstw.jpeg" /></figure><p>The main purpose of software tests; is that the software is free of bugs. It performs the expected functions. Software tests also positively contribute to projects staying within the expected budget and time. That’s why software tests need to be applied correctly to projects. The most useful software test for the project is a test strategy that is chosen correctly and applied correctly.</p><p>Brief description of the testing strategy; It is the definition of how the test objectives will be achieved and which tests will be performed at which level according to the characteristics of the software to be developed to achieve these objectives. In a good testing strategy, processes should be well evaluated. Important and error-prone parts of the project should be worded carefully. And the definitions made should be clear. Some mistakes are made in determining the testing strategy. One of the most common mistakes is trying to apply the same testing strategy to every project. Each project has its characteristics, needs, and expectations. This is a natural feature of projects. Therefore, a successful test strategy in one project may not be as successful in another. In order not to cause this error, the projects should be analyzed well.</p><p>Another important mistake in determining the test strategy is that the test strategy suitable for all levels cannot be determined. If this situation exists in a project, all test cases developed in each level test are run and the results of all of them are tried to be seen. However, successful software can be delivered with a flexible and effective test strategy in a project that is in trouble in terms of time and effort. Such a situation can be overcome by prioritizing and/or grading test cases and test scenarios within the test strategy. The remaining time and effort are used effectively.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/855/1*OAI9O4SlR7BNkIeS9vJ4Yg.jpeg" /></figure><p>We’ll briefly review the two most important testing strategies and check for key differences between them.</p><h3>What is TDD?</h3><p>Test-driven development is a testing strategy implemented by writing Unit Tests to test code and separate dependencies from code. The most important step of this strategy is to write the tests before the code is written.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/478/1*QsIa_A9mX4RzXgw6Z0qTgQ.jpeg" /></figure><p>According to the requirements, the developer writes a test case. These tests are performed and are expected to fail because they are written before a feature is developed. Re-coding is done to pass the test successfully. It is ensured that all tests are successful. The code is reviewed and edited, and improvements are made if necessary. The process of editing the code should not change the main function of the code. It only performs the process of improving or cleaning the code without changing the behavior of the code. This replacement and editing continue until the code receives no errors.</p><ul><li>Write Test</li><li>Test Fails</li><li>Write Code</li><li>Test Passes</li><li>Refactor</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/384/1*rvV11YOy8YJtiY1cjTTE6g.png" /></figure><p>For the developer, this process means that before a particular algorithm can be written to solve a problem, the code must be analyzed and its behavior must be known. It means that when writing a test with this process, a function will pass some conditions: its output.</p><blockquote><strong>In what situations would it be appropriate to choose this path?</strong></blockquote><blockquote>Choosing projects where the software process has started may not be appropriate. Moving forward with TDD intent can be tricky.</blockquote><blockquote>The test engineer should have software experience. Because in this strategy, coding knowledge is needed for the test engineer as well as the software developer.</blockquote><blockquote>It can be preferred in projects whose architecture may change later. If there is such a possibility, it is a strategy that will help facilitate processes.</blockquote><h3>What is BDD?</h3><p>Behavior Driven Development (BDD) is a derivative of TDD. Mainly based on system behavior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*XZPzVeiu-qQAE_Q9cwySWw.png" /></figure><p>While TDD asserts some conditions, BDD is written in plain text using real-time examples of real requirements to explain the behavior of the system. This way, you will ensure that up-to-date application documentation is created with these written texts.<br>Commands such as “<em>Given</em>”, “<em>When</em>”, and “<em>Then</em>” are used for test scenarios.</p><p>As an example;</p><ul><li>Given: Initial State</li><li>When: Action takes place</li><li>Then: Expected Outcome</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gZrHpUEDwijrOngv4IeCkQ.png" /></figure><p>For example;</p><h4>Case 1</h4><p><strong><em>Given</em></strong>: <em>The Name field is entered correctly on the login form</em><br><strong><em>When</em></strong>: <em>Click the Login button</em><br><strong><em>Then</em></strong>: <em>A warning message should be displayed for the Surname</em></p><h4>Case 2</h4><p><strong><em>Given</em></strong>: <em>The Name and Surname fields are entered correctly on the login page</em><br><strong><em>When</em></strong>: <em>Click the Login button</em><br><strong><em>Then</em></strong>: <em>Successfully logged in</em></p><p>Helps reach a wider audience with the use of spoken language. You move to a different level of abstraction than usual when describing the behavior of the software. It facilitates communication between software developers, testers and analysts, and administrators. Acceptance criteria can be created before development. Some tools based on the BDD framework are used to write acceptance tests for practice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/389/1*TkAB50MOKlN1sl1HdyLLDA.jpeg" /></figure><p>The most well-known of these is Cucumber. Cucumber is easily readable and understandable. Cucumber can also be used with Selenium. Along with Java language, it supports many other languages ​​such as Perl, PHP, Python, and .Net.</p><blockquote><strong>In what situations would it be appropriate to choose this path?</strong></blockquote><blockquote>This strategy can be chosen if the test engineer has no software experience.</blockquote><blockquote>It can be selected if the test process communication between different units will be provided directly. Since test cases are written in spoken language, it is the strategy that makes communication the easiest.</blockquote><blockquote>Test Senaryoları yazılım bilgisi olmayan kişiler tarafından hazırlanacaksa bu stratejinin seçilmesi uygun olabilir.</blockquote><h3>What are the Advantages?</h3><h4>What are the Advantages of TDD?</h4><ul><li>Reduces the maintenance burden</li><li>Errors are easily visible</li><li>Better designs can be realized</li><li>When the code is written, it is testable</li><li>The code is easy to understand as it is driven by tests</li><li>Makes it easy to change the architecture of the application</li></ul><h4>What are the advantages of BDD?</h4><ul><li>Test scenarios are written in spoken language, so they are easy to understand</li><li>Increases and develops cooperation</li><li>As test scenarios are created and put into code through the user stories determined for the customer’s needs, the identified needs are better met</li><li>It is easier to implement and learn as it is not a technical strategy</li></ul><h3>Which one is the best?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*usmAK35u6X1FU10P8UQs0w.jpeg" /></figure><p>If you’re looking for the answer to this question, you haven’t thoroughly studied this article. But I’ll still tell you which strategy is better.</p><p>One way to find the correct answer to this question is;</p><blockquote><strong>Get to know your project</strong></blockquote><blockquote><strong>Get accurate information about testing strategies</strong></blockquote><blockquote><strong>Choose a strategy that fits the project</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42ff5ae223cf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/test-strategy-process-tdd-bdd-42ff5ae223cf">Test Strategy Process(TDD&amp;BDD)</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is The Test Case?]]></title>
            <link>https://medium.com/beyn-technology/what-is-the-test-case-455b4044ae16?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/455b4044ae16</guid>
            <category><![CDATA[test-case-management]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[non-functional-testing]]></category>
            <category><![CDATA[test-case]]></category>
            <category><![CDATA[functional-testing]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Mon, 31 Oct 2022 12:56:40 GMT</pubDate>
            <atom:updated>2022-10-31T12:56:40.170Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/310/1*UPGFdaDi-I_mNNLqb1MQgA.png" /></figure><p>Many teams have problems with their testing processes. The general error here is; It is a misunderstanding of the concepts found in the testing processes. I believe that there is no one right way in this process. But understanding the concepts will provide us with a more understandable process. In this article, I will try to explain these concepts to you. I will give some examples in life about this process.</p><p>Test cases describe how to test a system, software, or application. A test case is a singular set of actions or instructions that a tester must perform that validates a particular aspect of a product or app functionality. If the test fails, the result may be a software bug that the organization can prioritize.</p><p>A tester or QA professional typically writes test cases that run after the completion of a feature or set of features that make up the release. Test cases also verify whether the product meets the software requirements.<br>A group of test cases is organized in a test suite that tests a logical part of the application, such as a particular feature.</p><h3>Types of Test Cases</h3><p>To validate and validate system functionality, the organization must take a multifaceted approach that evaluates the front-ends and back-ends of the product. There are different ways to categorize various test cases.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*UjPTNeo4XWpydXfNvN_0Ug.png" /></figure><h4>Formal Test Cases</h4><p>In such test scenarios, the tester writes a test where the inputs such as prerequisites and test data are all known and detailed. Formal tests have predefined inputs, which means they provide an expected output that the test is trying to validate.</p><blockquote>For example in life, we want to test an elevator. Let’s assume that we are given information about what action will be taken on which key is pressed. And let’s test based on this information. The elevator will go to the first floor when the button that says “1” is pressed. In our formal test case, the inputs for this process and the result are clear and we check whether we go to the first floor.</blockquote><h4>Informal Test Cases</h4><p>Conversely, informal test cases have no known inputs or outputs. Testers run such test scenarios to discover and record results that could reveal interesting findings about digital quality.</p><blockquote>For example in life, Let’s test an elevator again. Let’s examine if the elevator moves up and down. You thought that input is required in this. But we will not check that it goes up when a key is pressed, but only if it moves up. So press the key you want. If you see it go up, the test is successful. As you can see, we didn’t need input to test this situation.</blockquote><p>Most test case types are formal — preplanned based on software requirements.</p><h4>Test case types :</h4><ul><li>Functionality</li><li>User Interface</li><li>Integration</li><li>Performance</li><li>Usability</li><li>Database</li><li>User Acceptance</li><li>Exploratory</li></ul><p>I will explain these types in detail in another article.</p><h3>Test Case Results</h3><p>While the purposes of test cases differ, most formal ones have predictable results. The typical test case format should detail the expected and actual results, which the test itself validates.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*SEXNFTxgI_a8duySWsnVEA.jpeg" /></figure><p>Most test case results :</p><ul><li>Pass</li><li>Fail</li><li>n/a</li><li>Blocked</li></ul><p>Successful and unsuccessful tests indicate that the system has succeeded or failed in this attempt. These results should not be confused with tests designed to be positive or negative, which may pass or fail. Positive tests allow users to go through all the steps and pass the expected result when the input is correct. Negative tests ensure that the system correctly handles invalid input, such as disallowing a login if a password is incorrect. Both types of tests either pass or fail depending on the expected result.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/281/1*Dx6XDH1A0nyOn4fOyD7OFg.png" /></figure><p>Test results marked as not executed, as the name suggests, are tests that have not yet run or will not run as part of this round of testing. Blocked tests are caused by an external condition or precondition that prevents the test from running. For example, a system failure that prevents functionality from being available will result in a blocked test, such as a misconfigured test environment.</p><blockquote>For example in life, Above, we tested the elevator in certain conditions. Now let’s examine these test results.</blockquote><blockquote>In the example I gave for the Formal Test Case, we pressed the number 1 button and went up to the first floor. Let’s consider two cases for this scenario.<br>Case 1(Positive Test):<br>“We have to go to the first floor when button 1 is pressed”<br>Test Result:<br>Pass: if the elevator went up to the first floor and stopped<br>Perpetrator: elevator failed to reach the first floor or went to another floor<br>n/a: The test could not be performed because there is no elevator in the building.<br>Blocked: the elevator will be repaired. and waiting for the repair to be finished to test it.</blockquote><blockquote>Case 2(Negative Test):<br>“When the door open button is pressed while the elevator is in motion, the door should not be opened.”<br>Note: Since this case is negative, the test is valid in negative cases. In other words, even if the door does not open seems like a negative situation, the test is successful when the door is not opened, since this is the desired situation.<br>Test Result:<br>Pass: If the door is not opened while moving<br>Perpetrator: If the door is opened<br>n/a: The test could not be performed because there is no elevator in the building.<br>Blocked: the elevator will be repaired. and waiting for the repair to be finished to test it.</blockquote><h3>Test Case Format</h3><p>Test case documents typically contain all relevant information for running the test and collecting data from the test. While the specific test case format differs between organizations, most include the following details:</p><ul><li><strong>Module Name:</strong> This is the module or feature being tested.</li><li><strong>Test ID or Name:</strong> This is a unique identifier that must follow a standard naming convention.</li><li><strong>Test User Name: </strong>The person doing the test.</li><li><strong>Test Data:</strong> This describes the datasets to be used for testing.</li><li><strong>Assumptions or Preconditions:</strong> Explain the various steps that must be performed before the test, or what we can state situationally assume about the test, such as “after a successful login”.</li><li><strong>Test Priority:</strong> Identify whether the test is low, medium, or high priority.</li><li><strong>Test Scenarios:</strong> As explained above, this is the high-level action from which the test case derives.</li><li><strong>Test Environment:</strong> Define the name and/or properties of the environment to be tested.</li><li><strong>Test Steps:</strong> Detail the steps that the tester must follow in the desired order.</li><li><strong>Expected Results:</strong> This is the output you expect to get from the system.</li><li><strong>Actual result:</strong> This is the output you get from the system.</li><li><strong>Pass/fail determination: </strong>If the actual results match the expected results, the test is successful. If not, the test will fail.</li></ul><p>By following the test case format above, the organization can adhere to a standard method of writing tests, which is useful during maintenance. The organization should regularly review, maintain and approve test cases to ensure they adequately cover new and legacy functionality. Fully detailed test cases reduce the need for time-consuming exploratory testing to fill coverage gaps.</p><blockquote>For example in life; We’ve been testing an elevator for some time now. However, we were not given any information about this elevator. First, we need to know what kind of elevator we are testing (with automatic door, sliding door, touch screen, etc.)<br>After this information, another important piece of information is the details of our cases. I have explained the necessary details above. Let’s think of a few questions for our elevator frames and try to answer these questions according to the information above.<br>- Who tested the elevator?<br>- What information is required before starting the test?<br>- Is preparation necessary? If necessary, what are they?<br>- Test priority?<br>- How should the test steps be?<br>When we look at these questions, we see how many parts remain unanswered. If we fill in the above fields, these questions will not return to us as time costs.</blockquote><h3>Writing Test Cases Efficiently</h3><p>Well-written test cases have benefits; good quality products, higher profits(time and money), and easier test maintenance.<br>However, it takes some effort and organization to write test cases that help achieve these goals.</p><p>Generally, the tester should write test cases early in the SDLC (System Development Life Cycle) and during the requirements-gathering phase. Testers should refer to the requirements and use case documentation as well as the overall test plan when writing test cases. A prototype can also tell the tester what the feature or functionality will look like when complete.</p><p>Once the tester has all this information, they can start writing the various test cases mentioned above. When writing test cases, the tester must consider application flows — how the user arrives at application functionality is an important element of their journey and should be properly validated.</p><p>Write test cases clearly and concisely to ensure accuracy no matter who reads and performs the test. While some details are important, aim to keep test cases economical and highly easy to execute to reduce maintenance when the application changes. Well-written test cases should also be repeatable and reusable; several tests are run only once, and reusable tests can save time when developing additional functionality. Make each traceable so documents and results can easily inform the team.</p><h3>Test Case Management</h3><p>One way to make sure test cases are easy to find and understand is to give them a thorough review. The naming conventions and descriptions of test cases should be consistent. The sanity check can also reveal whether the author’s “simple” explanation of the testing steps makes sense to another reader and reflects real-world conditions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*xKlQUYU-6Bsvp4JyFGfwWA.png" /></figure><p>The larger the scope of a product, the larger the footprint of test cases. Simply put, the more you develop, the more you have to test, which can cause difficulties in scaling test suites. Test cases need to keep up with new functionality, and the need for regression testing means legacy test cases also need updates.</p><p>Test management tools or products can help organizations monitor and update tests as needed. There are so many options for test management tools. Ultimately, the best option is the one that fits as seamlessly into your workflows as possible, allowing the team to view, interpret, and access audit trails.</p><p>Reporting is an important element of test case management. Test case reports should give the team actionable information on how testing is progressing, what scope you have, and where the team can improve in the future.</p><p>While managing test suites can be daunting, maintaining digital quality for your products is ultimately a necessary task. If the task is difficult to maintain internally, look for tools or services to help you get on with it.</p><blockquote>For example in life, In some of our cases, we could not test it because the elevator was repaired. This is actually a matter of planning and management. The processes from the moment we start creating cases to the moment we test them should be planned. Of course, there can be setbacks. We may encounter unexpected situations. However, in order to minimize these situations, we should use the time when the repair is finished, not the time the elevator is repaired, to test it. Maybe the elevator was not repaired correctly and this will give us the wrong result!</blockquote><p>I am trying to explain the Test Case in this article. We will keep together about QA. I hope, this article can help you. <br>See you next time!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=455b4044ae16" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/what-is-the-test-case-455b4044ae16">What Is The Test Case?</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cross Browser Testing(Selenium and TestNG)]]></title>
            <link>https://medium.com/beyn-technology/cross-browser-testing-selenium-and-testng-f6ce11a861aa?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6ce11a861aa</guid>
            <category><![CDATA[cross-browser-testing]]></category>
            <category><![CDATA[testng]]></category>
            <category><![CDATA[qa-testing]]></category>
            <category><![CDATA[selenium]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Thu, 29 Sep 2022 09:38:23 GMT</pubDate>
            <atom:updated>2022-09-29T09:38:23.964Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*5E2OFw2SkuJ3BmESAbCiZA.png" /></figure><p>Multi-browser testing or cross-browser testing is an essential requirement for your test process. We need Selenium to test websites that check browser drivers. For using Selenium efficiently, we need TestNG. We will do the Cross Browser Testing process using TestNG with Selenium.</p><h3>What is Cross-Browser Testing?</h3><p>Cross-browser testing is the process of testing our website on different browsers and operating systems. With cross-browser testing, we ensure that the site is the same in every browser. We can perform cross-browser testing automatically. When cross-browser testing, we care not only about browsers but also their different versions and operating systems.</p><h3>Why is Cross Browser Testing important?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FWcLVZjPV-vxWOoNaIBVzA.jpeg" /></figure><p>Browser vendors follow Open Web Standards but have their interpretations. Because each renders HTML, CSS, and JavaScript in unique ways, extensive debugging of a website’s source code isn’t enough to make the site look and behave as intended in different browsers. So it’s up to web developers to abstract away browser differences. Cross-browser compatibility testing helps locate browser-specific compatibility errors so they can be quickly debugged. It helps to ensure that a site does not alienate a significant portion of its target audience because the website does not work on browser operating systems.</p><p>By this point, you should have understood that the idea of ​​cross-browser testing is due to the different engines we install the browsers on to render web languages ​​.</p><h3>Cross Browser Testing using Selenium</h3><p>In the code below, we will demonstrate how to perform cross-browser testing in TestNG using the Selenium web driver.</p><pre>import org.openqa.selenium.By;<br>import org.openqa.selenium.WebDriver;<br>import org.openqa.selenium.opera.OperaDriver;<br>import org.openqa.selenium.chrome.*;<br>import org.testng.annotations.AfterClass;<br>import org.testng.annotations.BeforeClass;<br>import org.testng.annotations.Parameters;<br>import org.testng.annotations.Test;<br><br>public class MultiBrowserTesting {<br><br>	public WebDriver driver;<br><br>  @Parameters(&quot;browser&quot;)<br><br>  @BeforeClass<br>  public void beforeTest(String browser) {<br><br>  // If the browser is Opera<br>  if(browser.equalsIgnoreCase(&quot;opera&quot;)) {<br>	 <br>//Initializing the opera driver<br>	  driver = new OperaDriver();	  </pre><pre>// If the browser is Chrome<br>  }else if (browser.equalsIgnoreCase(&quot;chrome&quot;)) { <br><br>	  //Initialize the chrome driver<br>	  driver = new ChromeDriver();<br>  } <br><br>  // Website address in the browser<br>  driver.get(&quot;https://www.example.com&quot;); <br><br>  }<br><br>  // Once Before method is completed, the  Test method will start<br>  @Test public void tests() throws InterruptedException {<br><br>	driver.findElement(By.xpath(&quot;example[div]&quot;)).click();<br>	}  <br>  @AfterClass public void afterTest() {<br>		driver.quit();<br>	}<br>}</pre><p>Since we are using the TestNG parameters, we need to specify the values ​​in the TestNG XML file that will pass to the test case file.</p><pre>&lt;!DOCTYPE suite SYSTEM &quot;https://testng.org/testng-1.0.dtd&quot; &gt;<br>&lt;suite name=&quot;Suite&quot; parallel=&quot;none&quot;&gt;<br> 	&lt;test name=&quot;OperaTest&quot;&gt;<br> 		&lt;parameter name=&quot;browser&quot; value=&quot;opera&quot; /&gt;<br> 		&lt;classes&gt;<br> 			&lt;class name=&quot;MultiBrowser&quot; /&gt;<br> 		&lt;/classes&gt;<br> 	&lt;/test&gt;<br> 	&lt;test name=&quot;ChromeTest&quot;&gt;<br> 		&lt;parameter name=&quot;browser&quot; value= &quot;chrome&quot; /&gt;<br> 		&lt;classes&gt;<br> 			&lt;class name=&quot;MultiBrowser&quot; /&gt;<br> 		&lt;/classes&gt;<br> 	&lt;/test&gt;<br>&lt;/suite&gt;</pre><p>The above piece of code does the following;</p><ul><li>Initialize a parameter with the browser name.</li><li>Start the scanner driver depending on the parameter value. For a browser value equal to Chrome, start a chrome driver, etc.</li><li>Open the “example.com” website in the browser and click on an item with the help of Selenium.</li></ul><p>In this XML file, the code specifies different classes for drivers to instantiate browsers to run test cases on the website.</p><p>After understanding the above code, run the code in the XML file as mentioned above with parameter values ​​like Opera and Chrome.</p><h3>What are the benefits of cross-browser testing?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*IaWglw2NFkkzYzX22NbzOQ.png" /></figure><ul><li>Different browsers offer the same user experience.</li><li>Browser-specific functionality does not affect the end-user experience.</li><li>The website maintains its performance even as new device and operating system combinations are introduced.</li><li>Each browser responds acceptably to changes in features or functionality.</li></ul><h3>What are the advantages of cross-browser testing?</h3><h4>Concurrent Test Execution Results in Faster Testing</h4><p>The biggest challenge posed by automation testing is scalability. The need to run each test on all possible combinations of different browsers, different versions, operating systems, different versions, devices, and platforms makes it a tedious and time-consuming task. What makes it worse is that every time there is a new build or fix that requires testing, your testing team will have to rerun all those tests on all these browser combinations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*1YPmXVg40cBQyuctAz0jLg.png" /></figure><p>You can easily reduce this difficulty by leveraging automation. Automatic cross-browser tests help you run parallel tests quickly and simultaneously across combinations, resulting in much faster delivery.</p><h4>Save Time and Money</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/290/1*BIl3T6wAcnlQq6AJyalFcA.png" /></figure><p>Cross-browser testing often requires mundane and repetitive testing, which can be a tedious and time-consuming task if done manually. By identifying and automating all common tests that need to be repeated across all browser combinations, you can not only save time but also improve return on investment (ROI).</p><h4>Higher Test Coverage</h4><p>One of the biggest challenges of cross-browser testing is the need to run and re-run tests across many different browsers, platforms, and device combinations. Oftentimes, test teams are short on time and have to skip some of these combinations for lack of time.</p><h4>More Accurate Test Results</h4><p>With automation, human errors can be completely avoided. This can result in improved test accuracy as your test automation tool is free of human emotions such as boredom, fatigue, or stress that result in frequent surveillance.</p><h4>Get More Testing Done With Fewer Resources</h4><p>This can be a general benefit in any type of test automation, but it also applies to cross-browser testing. By using test automation to run your cross-compatibility tests, you will need far fewer testers than you would if run manually. This helps in faster test execution that not only scales but also saves time and money.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6ce11a861aa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/cross-browser-testing-selenium-and-testng-f6ce11a861aa">Cross Browser Testing(Selenium and TestNG)</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is the TestRail?#2]]></title>
            <link>https://medium.com/beyn-technology/what-is-the-testrail-2-1a96fb3b6c93?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a96fb3b6c93</guid>
            <category><![CDATA[testrail]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[qa-testing]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Wed, 24 Aug 2022 11:35:32 GMT</pubDate>
            <atom:updated>2022-08-24T11:35:32.794Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, we will learn about the main elements of TestRail. In the previous article, I gave detailed information about TestRail. The difference in this article is that it contains information that will help us to use TestRail more dynamically.</p><h4>1. Dashboard</h4><p>After logging into TestRail, the Dashboard page welcome us. This part has been desing simple and dynamic.</p><p>You see your all project on this page. There are Graphic, Projects, and Todos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H18ClkivayEzslHwMX0iSQ.png" /></figure><ul><li><strong>Graphic</strong></li></ul><p>The graph shows the number of transactions in the projects daily. This graphic shows all projects and all members’ activities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1010/1*L67ivsBa9j8bQzfOhVj72g.png" /></figure><ul><li><strong>Project</strong></li></ul><p>We choose the project we want to work on from these fields. From the headings under the project names, we can reach the location we want to go directly and start working.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9X1-DOKx6c7x6LIr850zDw.png" /></figure><ul><li><strong>Todos</strong></li></ul><p>Todos field shows the actions to be taken on the person. In these fields, we see the number of test cases that are not “Passed”.</p><h4>2. Milestone</h4><p>In this field, the date range of the tests to be performed is known. For example, suites that need to be done in sprints can be added to these parts. The use of this area may not be suitable for every project. I would not recommend adding it for tests that are not exactly timed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EgASv6C2upeaYo_5Y3q6lQ.png" /></figure><p><strong>Step 1</strong>: Fill in the milestone’s property</p><p>Name(<em>required</em>), References, Parent, and Description</p><p>You can find more details about the property from the TestRail <a href="https://www.gurock.com/testrail/docs/user-guide/">document</a>. The only place that differs in this section is the References area. This part is where the connection of the relevant case with Jira is made.</p><p><strong>Step 2</strong>: Select Start and End date</p><p><strong>Step 3</strong>: Click “Add Milestone”</p><p>After adding the milestone, you can see your milestones on the Milestones page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*waQwPIiZtZ3DMxBFtP-k2g.png" /></figure><h4>3. Todo</h4><p>When a test case or test run is assigned to a user, it appears on the user’s to-do list. Each user has a to-do list for each project assigned to them. The dashboard provides a quick view of the user’s to-do task for all projects. The to-do section can also be used to view the to-do list of other team members or the entire team. It provides an easy way to see individual team members’ workloads and progress.</p><p>In this area, the person sees the tasks that are waiting for him. For the jobs to appear in this field, the “Assing to” field must be filled in when changing the status.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/1*uFRAPpZzpgNmzRahYPUMyg.png" /></figure><p>You can see the tasks whose status are “Untested, Retest, and Failed”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4CW3jd2eb4uwBBdBn5XDqA.png" /></figure><h4>4. Reports</h4><p>TestRail supports multiple reporting. It supports Test Case and Test Execution Reports. Generate a detailed summary report for projects, milestones, plans, and Runs. Track the workload of the entire team. It supports Cross Project Report as well.</p><p>Reports are generated from the “Test Runs&amp;Result” field and listed in the “Reports” field. For which “Test Run” you want to generate a report, you can create a report specific to that run.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*g1GL5NFVyqcW4sU5-7A6dA.png" /></figure><p>When you click on the report type you want to select, you can create a report by filling in the relevant sections and specifying the properties in the window that opens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q7X_jFuXNrBFU78yAkVC-A.png" /></figure><h4>4.1 Type of Reports</h4><p>TestRail supports some reports in different groups as explained below;</p><h4><strong><em>Cases</em></strong></h4><ul><li><strong><em>Activity Summary</em></strong><em>: </em>Shows a summary of new and updated test cases.</li><li><strong><em>Coverage for Reference:</em></strong> Indicates test case coverage for references in the coverage matrix.</li><li><strong><em>Property Distribution: </em></strong>Priority, Creator, Template, Type, etc. Shows a summary of test cases grouped by attributes.</li><li><strong><em>Status Tops:</em></strong> Shows test cases with the highest amount of results for selected cases, grouped by case.</li></ul><h4><strong><em>Defects</em></strong></h4><ul><li><strong><em>Summary: </em></strong>A milestone shows a summary of the defects found for test plans or test runs.</li><li><strong><em>Summary for Cases:</em></strong> This shows a summary of defects found for test cases in the coverage matrix.</li><li><strong><em>Summary for References:</em></strong> Shows a summary of the defects found and their test cases in a coverage matrix for references.</li></ul><h4>Results</h4><ul><li><strong><em>Comparison for Cases:</em></strong> This shows the results of test cases in the coverage and comparison matrix.</li><li><strong><em>Comparison for References:</em></strong> This shows the result of test cases in the coverage and comparison matrix.</li><li><strong><em>Property Distribution:</em></strong> Shows a summary of tests grouped by a selected attribute for a particular project, milestone, or test run.</li></ul><h4>Summary</h4><ul><li><strong><em>Comparison for Cases:</em></strong> This shows the results of test cases in the coverage and comparison matrix.</li><li><strong><em>Comparison for References:</em></strong> This shows the result of test cases in the coverage and comparison matrix.</li><li><strong><em>Property Distribution:</em></strong> This shows a summary of tests grouped by a selected attribute for a particular project, milestone, or test run.</li></ul><h4>Users</h4><ul><li><strong><em>Workload Summary:</em></strong> This shows the current workload for users of the entire project, specific milestone, or test runs.</li></ul><h3>What are the Advantages &amp; Disadvantages?</h3><p><strong>Advantages</strong>:</p><ul><li>Understandable Interface</li><li>Full integration</li><li>Drag &amp; Drop with Screenshot Support</li><li>Test Report</li><li>JIRA &amp; Issue Tracker</li><li>Test Plans</li><li>Platform Configurations</li><li>Batch Editing Cases &amp; Adding Results</li><li>Amazon advanced technology partner</li></ul><p><strong>Disadvantages</strong>:</p><ul><li>Not an open-source</li><li>No Requirement Management</li><li>No External dashboard</li></ul><p>TestRail supports more than 100 plugins to connect different software to make it easy to work with. A wide range of add-ins makes it universal across the globe — JIRA, Bamboo, HipChat, BugZilla, egg Plant, Cucumber, Jenkins, Selenium, etc.</p><p>Considering these advantages and disadvantages, you can use TestRail in your projects. In my opinion, the biggest feature that distinguishes TestRail from other tools is its easy interface. The user can learn a lot of features with a little tampering.</p><p>As a big mistake, TestRail is compared to Jira. We can do a lot of things in Jira that we can do in TestRail. But TestRail is produced as a “Test Management Tool”. Therefore, it is necessary to consider only these parts when making comparisons. In Jira, on the other hand, the “Test Management” field is a feature it contains. The main purpose of Jiran is agile project management.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a96fb3b6c93" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/what-is-the-testrail-2-1a96fb3b6c93">What is the TestRail?#2</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is the TestRail? #1]]></title>
            <link>https://medium.com/beyn-technology/what-is-the-testrail-1-620d75f93729?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/620d75f93729</guid>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[testrail]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Tue, 31 May 2022 08:47:54 GMT</pubDate>
            <atom:updated>2022-05-31T08:47:54.650Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*rYiZ1O8qKMPbh9IoiuE3UQ.jpeg" /></figure><p>In this article, I will give you information about TestRail.</p><p>The first thing I noticed when I went through the TestRail usage documentation was that the documentation didn’t contain new updates. And information about the purpose of use of some features is not given.</p><p>In this case, we will learn what is the main purpose of the things we use when creating a Test Project.</p><h3>What is the TestRail?</h3><p>TestRail is a web-based test management tool where we can follow the progress of the tests, easily create test scenarios, and run these tests.</p><p>There is a simple life cycle for TestRail.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/305/1*Q2iEXNbv2lssuJvovgFCmQ.png" /></figure><p>Based on this cycle, the project becomes traceable. At the same time, tests progress in a certain order.</p><h3>How can create the projects?</h3><h4>1. Project</h4><p>Projects are the main unit in TestRail. Suites, Test runs, test results, milestones, etc. are directly associated with a specific project. All projects are individual in themselves.</p><p><strong>Create Project</strong></p><p>When you click “+ Add Project” on the Dashboard, the page opens. In this part, you need to fill the required fields and create the project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-uHoliHxAOf_F32AGWZoSQ.png" /><figcaption>“Add Project” Page</figcaption></figure><p><strong>Step 1</strong>: Give the name of the project</p><p><strong>Step 2</strong>: Select a suite’s type for your project</p><p><strong>Step 3</strong>: Click the “Add Project” button</p><p><strong><em>Note</em></strong><em>: If you want, you can add an announcement.</em></p><p>The project we have added will appear in the Projects section of the Dashboard.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7q1DRLtebh5SqUQyfS2VFA.png" /></figure><p>When the select the project, the Overview page will appear. You see a summary of the project on this page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZWUJhyd_c3GQKQGvVA0IjA.png" /></figure><h4>2. Test Suit</h4><p>Test Suite is the structure in which test cases are collected and executed. Suite is the biggest element of a project. We collect our Test Cases with Suits under the main headings. This is the first step of the create an understandable and orderly project.</p><p><strong>Create Test Suite</strong></p><p>Suite is created by clicking the “+Add Test Suite” button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ALR05Cvdw32kWUGZ0Q6JLg.png" /></figure><p><strong>Step 1</strong>: Give the name of the suite</p><p><strong>Step 2</strong>: Click the “Add Test Suite” button</p><p><strong><em>Note</em></strong><em>: If you want, you can add a description.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9jEdygbXdFauJXjyamTrPw.png" /></figure><h4>3. Test Case</h4><p>Test cases define how to test a system, software, or application.</p><p><strong>Create Test Cases</strong></p><p>One of the best features of TestRail is that it allows the creation of test cases easily.</p><p>While preparing test scenarios, care should be taken to ensure that they are clean and orderly. For this, we can collect the same cases under the sections. The section helps to organize your test cases and helps to gather our tests under the main headings.</p><p>For this, we use the “+ Add Section” and “Add Subsection” buttons.</p><p>Firstly click the “+ Add Section” button for the create section. (if you want, you can start with cases directly.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ccLR6vhVL3j-nSboWtH7TA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/754/1*TO6wDUgpi7ahxfarejnF5g.png" /></figure><p><strong>Step 1</strong>: Give the name of the section</p><p><strong>Step 2</strong>: Click the “Add Section” button</p><p><strong><em>Note</em></strong><em>: If you want, you can add a description.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qOkcTqLR5CmDCCstfe06Dg.png" /></figure><p>Now, we can start to create test cases. We have two ways of creating cases. If we want to create test cases in detail, the “Add Test Case” button should be clicked. Cases are added in detail on the screen that opens. Or click the “Add Case” button for the create cases, after that you can give more detail.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/439/1*iJ61UshNQaXuMQirLqZPjA.png" /><figcaption>Create with detail</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ksJBYTyan82zjCWMcEbVFA.png" /><figcaption>Create without detail</figcaption></figure><ul><li><strong>Create Test Cases with detail</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ByPE6RDshZHNOtxmYGP0Ng.png" /></figure><p><strong>Step 1</strong>: Fill in the case’s property</p><p>Section, Template, Type, and Priority have already been filled. You can change according to your cases.</p><p>The only place that differs in this section is the References area. This part is where the connection of the relevant case with Jira is made.</p><p><strong>Step 2</strong>: If you have a precondition before the test, you should be writing the conditions here</p><p>For example; Open the game, click the “X” button, select the “X” etc.</p><p><strong>Step 3</strong>: You write the test steps here. Steps are should be clear and sufficient. You should write step by step.</p><p><strong>Step 4</strong>: You write expected results. You should write what you expect after your test steps.</p><p><strong>Step 5</strong>: Click the “Add Test Cases” or “Add &amp; Next” button.</p><ul><li>Add Test Cases: when you click the button, your cases save and close the page.</li><li>Add &amp; Next: when you click the button, your cases save and you can continue the next cases.</li></ul><p>After these steps, your cases are added to the suite.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7DQzVo5YKgApUXu77nMAeg.png" /></figure><ul><li><strong>Create Test Cases without detail</strong></li></ul><p>When you click the “Add Case” button, the “Case Title” field appears. Write a name and click the green button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JgdBYE5E-Oq-4WqTSz4Xsg.png" /></figure><p>Our case has been added and the Case Title field stays on the screen. You can continue adding the cases. (You need to add the details after adding if needed.)</p><p>Subsections can be created with “Add Subsection”. The project will be shaped according to the dynamics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*holx307hwBJZy55Pu-TEIw.png" /></figure><p>You can add subsections in the same way. Click the “Add Subsection” and the page opens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*K3SQy2ACWQFsJqnu5NYlYg.png" /></figure><p>Give a name and if you want, you can write a description. After this, click the “Add Section” button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iT06dVizymLtB40xc2onpg.png" /></figure><p>One of the nice features of TestRail is the copying of previously created test cases into newly created projects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OdJEfr0mL7mHt70Or7u__w.png" /></figure><p>When the button marked in the picture is clicked, the desired cases from the suites or projects are copied or moved from the opened window.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DI3uSOwKxUMG_s3WcqMC0A.png" /></figure><h4>4. Test Runs &amp; Results</h4><p>After adding cases, you need to run the suite. When clicking the “Test Runs&amp; Results”, we see the “Add Test Run” button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-bo6q1JiRjac-hRiXBo8PA.png" /></figure><p>After clicking the “Add Test Run” button, we must select the suite we want to run in the window that opens. And then we reach the following screen by saying “Add Test Run”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3NgSNKQcfWyDZOkuYllyIw.png" /></figure><p>When we click on the test case, we see detailed information about the relevant case in the right area.</p><p>When we test according to the information given, we can continue by selecting the Status field according to the result.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Sa_oUoQafvPcrKEEkSyMaQ.png" /></figure><p>As the test continues, the graphic changes according to the statuses. This helps us to analyze the Test Run more easily.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*ODBeqiepPNO_9N_FFZRrDw.png" /></figure><p>We can add comments in the pop-up window while changing the status field of test cases.</p><p>These comments can be reminders, informative, etc. For example, if the status is Failed, you can add the issue link(Favro, Jira, etc.) on Comment. It can be written why a retested status will be retested later. These comments can save you a lot of time afterward. You can add pictures.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=620d75f93729" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/what-is-the-testrail-1-620d75f93729">What is the TestRail? #1</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Postman Tutorial#1- What is the Postman?]]></title>
            <link>https://medium.com/beyn-technology/postman-tutorial-1-what-is-the-postman-51060540ae2e?source=rss-aa2ff3f6558e------2</link>
            <guid isPermaLink="false">https://medium.com/p/51060540ae2e</guid>
            <category><![CDATA[api-testing]]></category>
            <category><![CDATA[postman]]></category>
            <category><![CDATA[api-testing-tools]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Murat Feyzioğlu]]></dc:creator>
            <pubDate>Thu, 03 Feb 2022 13:54:58 GMT</pubDate>
            <atom:updated>2022-02-03T13:59:11.046Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ue_lpXDr5mlDUDx_C2lTTQ.jpeg" /></figure><h3>What is the Postman?</h3><p>Postman is a powerful HTTP client for testing, developing, sharing, documenting and monitoring APIs by enabling users to collect HTTP requests.</p><p>It has a very useful and easy interface. This makes Postman different from its peers. The automation feature of Postman is one of the biggest reason for using it.</p><p>You can automate APIs. You can use ready-made code pieces and easily integrate with other tools(Jenkins, Travis, CI, Docker, Newman etc.).</p><p>You can code with JavaScript and Python in Postman. you can quickly adapt to Postman thanks to its easy syntax.</p><h3>How to Download and Install?</h3><ul><li>Go to “<a href="https://www.postman.com/">postman.com</a>”</li><li>Select operation system</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jStIK5UDftQNZSSw9hnOLw.png" /></figure><ul><li>Click the marked button(Windows 64- bit)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*56RpRKtUuywNYYZj4iCmsw.png" /><figcaption>Automatically appear the appropriate option for the operating system</figcaption></figure><ul><li>After the download is finished, the setup application is run</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/312/1*upb0ppew2poITlp9huSMFQ.png" /><figcaption>If no other path is selected, it is downloaded to the “Downloads” folder</figcaption></figure><ul><li>Postman opens after a short install. In this area, there are options to create account and login with existing acoount</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V3701DBVTVOoGW9-EqEVow.png" /></figure><p><strong><em>Note</em></strong><em>: If you want to perform the account transaction later, you can click the “Skip and go to app” button</em></p><h3>Postman UI</h3><p>Now, you can start using Postman. In this part, I will explain simple UI information.</p><h4>1. Collection</h4><p>Postman’s collection folders make it easy to keep your API requests and elements organized.</p><h4>2. Request</h4><p>Send HTTP requests</p><h4>3. Environment</h4><p>An environment is a set of variables you can use in your Postman requests</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fWT_8vrfn_pJKUMbjxcqaw.png" /><figcaption>Marked with number that from title</figcaption></figure><p><strong>New:</strong> If you want to create HTTP Request, Enviroment, Collection etc. , you can use “New” button</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*89jxVYeqtB3z8_mbjlugIA.png" /></figure><p><strong>Import:</strong> You can import a new Collection with the “Import” button</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ED6R3hk8dQPB9nqJ_B1GDw.png" /></figure><ul><li>On the left, you can see our Requests and Collections. We can see the history of our changes on the collections from the History tab.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/483/1*AI0FCtdBtw9T6F_YkAP2Sw.png" /></figure><h3>How to create API request?</h3><p>It is very important to log in with the account to customize Postman. I am passing this step because it is very easy to create account.</p><p><strong>Note:</strong> You can create an account with “Create Free Account” on the login page.</p><h4>1. Create Workspace</h4><p>First step, we need to create a workspace. This step is crucial to stand out from other workspaces and share our test with our team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ns3j_YkFkk9etzz2Asn-rQ.png" /></figure><p>You can create a Workspace with the marked places in the picture.</p><ul><li>First way; Click File &gt; New and choose Workspace</li><li>Second way; Click Workspace tab on the header</li></ul><p><strong>Note:</strong> Both paths you choose will open the same screen</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4xAhHxp-9GIZmJfBYUaoUg.png" /></figure><p>You need to fill some fields on the screen of create.</p><ul><li><strong><em>Name</em>:</strong> It is the name we will see in the UI</li><li><strong><em>Summary</em>:</strong> You can give some information about your workspace’s goal.</li><li><strong><em>Visibility:</em></strong> You need to choose who can see your workspace</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oF_QnyJESiOLvgINUX5A8A.png" /></figure><p>When you fill required fields, you can click “Create Worspace” button. (The button will be clickable after filling the requried fields.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v4BBzLmj7vAQfq95JBGulg.png" /><figcaption>We can choose workspace from this tab.</figcaption></figure><p>We can see our workspace on the Workspace tab.</p><p>Now we created workspace and after this we do our process in this area.</p><h4>2. Preparation for Request</h4><p>We will send request and check response in this part. We need to URL for the send request and the URL need to return response. There are many website that use for this. I recommend you a website because it has simple UI and many options for request.</p><p>The website : <a href="https://reqres.in/">https://reqres.in</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b674xMxqxkhAqjgyVpyvdQ.jpeg" /></figure><p>When you scroll down, you will see tempaltes of request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ZYKDaF7CdqMbgoC3FEsbg.jpeg" /></figure><p>The field in the address bar shows our URL part. Endpoint request is the part that takes our URL to the point we want.</p><p>We will use “Get Single USer” for first example.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/463/1*2zWIJBwAD86jieVEtpSVQw.png" /></figure><h4>3. New Request on Postman</h4><p>Now we will create an environment where we will send the request that we will send in the postman. We learned how to use the New field from the previous steps. We will create HTTP Request from the New section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uD4LjSHVkNVUepeLwpoW7w.jpeg" /></figure><p>When we want to create a new HTTP Request, the following screen will meet us.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GYMo-PNJ-mMlRx6tTJdfnw.png" /></figure><p>Before starting the process, it is useful to save this part with the Save button. We don’t want to lose our request.</p><p>When we click Send button, we need to fill some part of the screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*nRjeEL48CgulUpODh5-bOQ.png" /></figure><p><strong><em>Request Name:</em></strong><em> You can give a name what do you want.</em></p><p><strong><em>Description:</em></strong><em> It’s optional. You can add summary for your request.</em></p><p>If you have noticed, the Save button is not clickable. And there is a warning like “You don’t have any collections.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*XClHpFL1MeEBcwQdrdtg8A.png" /></figure><p>We need to create a collection. I gave short information about Collection. But the collections are very important and i will give more detail on next session.</p><p>We can create Collection with “New Collection” button at button left.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*MKkqp-vLCi4lrINtUsiSYA.png" /></figure><p>When we click “New Collection” button, we will write a name for the collection and click “Create” button.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/569/1*9zOFIhG48rz7M697J1CijA.png" /></figure><p>We can click “Save” button after created collection.</p><p>You can see some places chanced. Because, now we are working our personalized area.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*0dSBAWW2_tajN6rv-XYEaw.png" /></figure><h4>4. Send Request</h4><p>Until this step, we have completed all the necessary steps to send a request. Now we only need the URL to send requests. And we can back the website about request template.</p><p>We will combine URL and endpoint. You can check title “2. Preapare for Request”.</p><p>Request URL: URL of Site + Endpoint for Single User</p><p>“<a href="https://reqres.in/api/users/2">https://reqres.in/api/users/2</a>”</p><p>We will paste URL to marked place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*kK1bp0O1k81YQoQIb7LcsQ.png" /></figure><p>Now, everything is ready!</p><p>Click Send button and see the magic!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/918/1*BTo3jgxAp_eDAd_p3G35oA.png" /></figure><h4>5. Check Response</h4><p>We have a response. We don’t now this response is correct or not. Let’s check from the website.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sRtMbZXo75-CPvvdVC4dnQ.png" /></figure><p>When we chose Single User, it gave some information about the response. For example, id, email, first_name etc.</p><p>Actually, logic is simple. We have some information about response before sending. We want to check, they are correct or incorrect. We use Postman for this. When we send request, we can compare informations of response. And we can automatized.( this is the main part)</p><p>Response from Postman:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/923/1*TOqbWtjLjvKDGJefbxFQGg.png" /></figure><p>You can compare manually for now. Next session we will learn more detail about request and response.</p><p>We will examine important part of Request and Response. What are theese ? When we use thesee?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*2Dya-JrcAGhtKb-_uWd2OA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*nA5cNow5AJMtjk4Dqk2Piw.png" /></figure><p>I hope, I was able to help you up to this point. See you next session!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=51060540ae2e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/beyn-technology/postman-tutorial-1-what-is-the-postman-51060540ae2e">Postman Tutorial#1- What is the Postman?</a> was originally published in <a href="https://medium.com/beyn-technology">Beyn Technology</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>