<?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 Yulia Shaifele on Medium]]></title>
        <description><![CDATA[Stories by Yulia Shaifele on Medium]]></description>
        <link>https://medium.com/@yuliashaifele?source=rss-3e4009c513eb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*6-a8WjV6K_iBoiXJIk9IFg.png</url>
            <title>Stories by Yulia Shaifele on Medium</title>
            <link>https://medium.com/@yuliashaifele?source=rss-3e4009c513eb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 15:19:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yuliashaifele/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[Creating a Test Policy from Scratch: A Step-by-Step Guide]]></title>
            <link>https://medium.com/@yuliashaifele/creating-a-test-policy-from-scratch-a-step-by-step-guide-5507e8005dc7?source=rss-3e4009c513eb------2</link>
            <guid isPermaLink="false">https://medium.com/p/5507e8005dc7</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Yulia Shaifele]]></dc:creator>
            <pubDate>Tue, 18 Feb 2025 16:01:46 GMT</pubDate>
            <atom:updated>2025-02-18T16:01:46.402Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*RlKMpAvNuTbrBT-Ook-23Q.png" /></figure><p>A <strong>Test Policy</strong> is a document that describes how testing is organized in your company or team at every stage of development. This “map” of processes helps new employees adapt faster and provides the existing team with a clear understanding of when, what, and how to test, as well as the quality requirements set by the business.</p><p>In this article, I’ve gathered practical tips and a structure that will help you create a <strong>Test Policy</strong> from scratch. The material is based on my own experience and insights from professional QA discussions.</p><h3>Why do you need a test policy?</h3><ol><li><strong>Transparency.</strong> Every team member knows at which point a QA engineer should get involved, and what is done at each stage of a feature’s lifecycle</li><li><strong>A Single Standard.</strong> Everyone uses the same terminology, templates, reporting formats, and checklists</li><li><strong>Reduced Errors and Risks.</strong> With a clearly defined process, you’re less likely to miss critical scenarios or neglect integration checks</li><li><strong>Faster Onboarding for Newcomers.</strong> A new tester or developer receives ready-made guidelines and can integrate more quickly</li></ol><h3>1. Determine key parameters and your testing environment</h3><p>Before you start writing your Test Policy, gather information about how development is structured in your company (or project) and in which environment(s) testing is performed.</p><ul><li><strong>Number of environments.</strong> How many environments (dev, test, stage, pre-prod) do you have? Who uses them and how?</li><li><strong>Merge process.</strong> How does a feature or task make its way to the correct environment? Which status indicates that a task is “ready” to be tested?</li><li><strong>QA involvement in environment transitions.</strong> Should QA re-check builds on intermediate environments, run smoke tests, or sign off on a release?</li></ul><p><strong>Why it matters:</strong> Having a clear picture of your environments is the foundation on which you’ll build your Test Policy. If your merging and release processes are chaotic, consider simplifying or at least documenting the current state first.</p><h3>2. Define the scope of your Test Policy</h3><p>What typically goes into a Test Policy? Let’s break it down, referencing real-world discussions and best practices:</p><ol><li><strong>Object of testing</strong><br>Describe which types of applications the policy covers: web, mobile, desktop, microservices, etc. Who is the product’s target audience? What is the system’s purpose?</li><li><strong>Key testing types<br>- </strong>Functional Testing (smoke, regression, negative scenarios, etc.)<br>- Non-functional (performance, security, usability)<br>- Authorized/Unauthorized scenarios (for systems with roles or logins)<br>- Integration Testing (if multiple dependencies are involved)<br>Clarify which testing types are mandatory, which are optional, and in what circumstances they are executed.</li><li><strong>Tools you use<br>- </strong>Task management system (Jira, YouTrack, etc.)<br>- Test case repository (TestRail, Zephyr, Confluence, etc.)<br>- Automation tools (Selenium, Cypress, Playwright, etc.)<br>- Performance testing tools or CI/CD platforms<br>Indicate which tools are utilized, any constraints, and where your tests should be stored.</li><li><strong>Test documentation<br>- </strong>Test plans and test runs<br>- How test cases are written and stored (format, structure)<br>- Bug reporting (requirements for titles, descriptions, steps to reproduce)<br>- Reporting (which metrics are collected, what the final report looks like)<br>If your company follows specific conventions (templates, tags), be sure to document them.</li><li><strong>Testing process throughout the task lifecycle<br>- Early QA involvement.</strong> When does QA join the process (requirements review, grooming, sprint planning)?<br>- <strong>Definition of ready.</strong> What must developers provide or complete for a task to be considered test-ready?<br>- <strong>Actual testing steps.</strong> Which tests are performed, how extensive they are, and how results are documented.<br>- <strong>Definition of done.</strong> Which defects are critical, which can be deemed “known” but acceptable; how is a final “quality statement” issued?<br>- <strong>Going live.</strong> Do you need a demo? Who writes the release notes? Which QA activities are necessary before production deployment?<br>- <strong>Handling missed defects.</strong> How do you respond if a major bug is discovered in production? Who decides if a hotfix or rollback is required?</li><li><strong>Risks and constraints<br>- </strong>Potential risks (lack of resources, unclear requirements, unstable environments), and mitigation strategies.<br>- Who is responsible for deciding if certain testing types will or will not be performed?</li><li><strong>Roles and responsibilities<br>- </strong>Who participates in testing: QA, Dev, DevOps, PM, stakeholders?<br>- When does each role step in, and what tasks do they own?</li><li><strong>Document templates<br>- </strong>Standard templates for test plans, checklists, bug reports, etc. Provide links or attach them as appendices</li></ol><h3>3. How to align the Test Policy with your team and stakeholders</h3><p>Writing your Test Policy is only half the battle; it’s essential to <em>align</em> it with key stakeholders:</p><ol><li><strong>Discuss the strategy with the Project Manager.<br>- </strong>Determine priorities: for instance, do you need performance testing every sprint or just quarterly?<br>- Agree on whether every negative scenario needs an automated test or if basic coverage suffices.<br>- Identify at which stage QA should be involved in the development process and whether there are enough resources.</li><li><strong>Review with the development team.<br>- </strong>The dev team may have concerns like “Why run smoke tests in all environments when stage alone might suffice?” or might suggest CI/CD tweaks.<br>- Decide who is responsible for setting up the test environment if you don’t have dedicated DevOps.</li><li><strong>Share the draft with the entire team.<br>- </strong>Provide a link to the document (Confluence or elsewhere) and ask them to comment.<br>- Incorporate feedback and finalize the document.</li></ol><h3>4. Example structure of a Test Policy (Mini-Template)</h3><p>Below is a brief outline you can use to create your final document or Wiki page:</p><ol><li><strong>Introduction: </strong>purpose of the document, intended audience, brief overview of the project</li><li><strong>Object of Testing: </strong>type of product, core modules, user base</li><li><strong>Test Strategy: </strong>types of tests, tools, environments</li><li><strong>Testing Process: </strong>entry/exit criteria, statuses, role interactions</li><li><strong>Test Documentation: </strong>formats and examples of test cases, bug reports, and overall reporting</li><li><strong>Risks and Assumptions: </strong>potential pitfalls (resource/time constraints, environment instability)</li><li><strong>Appendices: </strong>templates (test plan, checklists, report formats), links to internal Wiki resources</li></ol><h3>5. Practical tips for creating your Test Policy</h3><ul><li><strong>Start small.</strong> If you can’t document every testing type and process at once, begin with the most critical steps: how tasks reach QA and what QA does afterward. Expand gradually</li><li><strong>Use real examples.</strong> When specifying bug-report requirements, include screenshots or links to real bug reports (with confidential info removed)</li><li><strong>Include relevant links.</strong> Your Test Policy shouldn’t exist in a vacuum — reference the tools, CI/CD, coding guidelines, and security requirements you rely on</li><li><strong>Review periodically.</strong> Every six months or after any major process change, revisit the document to keep it accurate</li></ul><h3>Conclusion</h3><p>A well-defined <strong>Test Policy</strong> is not just a bureaucratic formality; it’s a tool that helps improve product quality and clarifies processes. Even if you’re starting with a blank slate, aim to structure it so every team member knows what they need to do and when. Gradually adapt the document to match real workflows, and encourage your teammates to provide feedback. Over time, you’ll develop a living, valuable “QA bible” that streamlines and accelerates your daily work.</p><p>I hope this article helps you craft your own Test Policy, drawing on key questions, discussions, and practical tips from the professional QA community. Good luck, and may your policy become the solid foundation for product quality!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5507e8005dc7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Key QA Metrics: How to Calculate, Implement, and Use Them Effectively]]></title>
            <link>https://medium.com/@yuliashaifele/key-qa-metrics-how-to-calculate-implement-and-use-them-effectively-6d5ab4517e40?source=rss-3e4009c513eb------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d5ab4517e40</guid>
            <category><![CDATA[quality-assurance]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[metrics]]></category>
            <dc:creator><![CDATA[Yulia Shaifele]]></dc:creator>
            <pubDate>Wed, 15 Jan 2025 15:14:47 GMT</pubDate>
            <atom:updated>2025-01-15T15:14:47.947Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*qQoKOF_7_u16w80KwVKVnA.png" /></figure><p>The other day I was chatting with a tester I know and we had this dialog:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/597/1*xlryiCtXyeNCFHrnLHG_XA.png" /></figure><p>After this dialog, I thought about how the metrics-related processes were set up in some of my projects:</p><ol><li>In one of them, only the developer was notified about critical bugs on the prod, who had to fix the bug urgently. As a result the bug is fixed, but the tester will not even be aware of this bug. This process makes it impossible to collect metrics related to bugs</li><li>In another project, not all tasks are tested by the tester. For example, some trivial changes may be rolled out in the release even without notifying the tester, although in fact these changes may cause some regression bugs</li><li>And on another project, where all tasks and bugs go through the tester — there are no metrics at all, because there was no sense in them specifically for that product. And that’s okay</li></ol><p>Each project is a separate story. Metrics can be a tool that aligns processes and helps the team, but they are definitely not universal or even always needed. In this article, I want to talk about some good metrics, namely how to calculate, implement and use them in the future. Let’s go!</p><h3>1. Test Coverage of Requirements</h3><p><strong>What is this metric?</strong></p><p>This metric will reflect how much of the requirements are covered by tests and helps to assess test completeness and minimize the risk of missing critical bugs.</p><p><strong>How is it calculated?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*sT12Xv4QQ9bIwBNChQVUfw.png" /></figure><p><strong>How to implement?</strong></p><p>Let’s say a team is developing an e-commerce platform. All requirements are decomposed and captured in Jira, the metric of requirements coverage by tests has not been implemented yet. Where to start?</p><ol><li><em>Define the coverage criterion</em>. For example, for this project, the team defined the following criteria: minimum of one happy path test, minimum of one negative test, and if the requirement involves checks for equivalence classes or boundary values, add a minimum of two checks for boundary cases (e.g., values at range boundaries) and one check for each equivalence class</li><li><em>Set up the system</em>: use tools like Xray or Zephyr in Jira to link requirements to tests. For each requirement, we add links to all linked tests</li><li><em>Collect data</em>: tools like Xray or Zephyr automatically collect data about test execution status and links to requirements. If such tools are not available, you can maintain data manually by capturing test results in tables or reports</li><li><em>Track progress</em>: in meetings, the team can discuss the current value of the metric, analyze the percentage of claims with coverage and areas with low coverage, assess the risks associated with missing coverage, plan actions to increase coverage and prioritize tasks, and check the dynamics of the metric to adjust the testing strategy</li></ol><p><strong>How to use the metric?</strong></p><ol><li><em>To plan for the expansion of test coverage. </em>The metric helps you identify which requirements are left without test coverage and prioritize tasks. For example, critical features with low coverage needs priority attention, which minimizes risks and improves team efficiency</li><li><em>To assess the risks of missing defects. </em>Low coverage of requirements with tests indicates risk areas. Requirements without tests may contain undetected defects that will affect system stability. Analyzing the metric allows you to proactively identify such areas and eliminate risks</li><li><em>For reporting to the business</em>. The metric provides understandable quantitative data about testing that can be used in reports to demonstrate the level of product readiness. This helps the business to see the value of testing and support decisions to allocate resources for quality improvement</li></ol><h3>2. Defects Found in Production</h3><p><strong>What is this metric?</strong></p><p>The rate of bugs detected in production shows how effectively testing identifies defects before release. This metric helps to evaluate the quality of testing and the defect filtering process by demonstrating the proportion of bugs that are passed to the vendor</p><p><strong>How is it calculated?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/769/1*GdsFzWMTR-g8VycS6X2oDA.png" /></figure><p><strong>How to implement?</strong></p><p>Let’s imagine that a team is developing a mobile banking application. The bugs identified on the production are not yet tracked as a formal metric. Where to start?</p><ol><li><em>Decide which bugs to include in the metric</em>. For example: only critical or serious bugs, or all bugs, including minor bugs</li><li><em>Create a feedback channel for end users</em>. For example, this could be sending a bug report within the application, or a message via a support or feedback form.</li><li><em>Tag all bugs found in production</em> for later collection of statistics. It is also important to associate bugs with a release or functionality so that metrics can be collected for a specific release or functionality</li></ol><p><strong>How to use the metric?</strong></p><p><em>To evaluate the quality of testing</em>. The metric helps to assess how effectively testing detects defects before release. If the ratio exceeds acceptable values (e.g., &gt;10%), it is a signal that testing processes are lame.</p><h3>3. Time to test the build</h3><p><strong>What is this metric?</strong></p><p>Time to test the build is a metric that measures how much time the team spends testing each build before releasing it. It reflects the speed and efficiency of testing processes.</p><p><strong>How is it calculated?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*i0Olc-qE-CKMoTYgK5isFQ.png" /></figure><p><strong>Example:</strong><br>For four builds, the following data was recorded:</p><ul><li>Build 14.1: testing started on 03.12 and ended on 11.12 (8 business days).</li><li>Build 14.2: testing started on 21.12 and ended on 29.12 (8 business days).</li><li>Build 14.3: testing started on 18.01 and ended on 24.01 (6 business days).</li><li>Build 14.4: testing started on 27.02 and ended on 01.03 (3 business days).</li></ul><p><em>Average testing time:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/424/1*zaWExtG1pB71n7BrkSC-vg.png" /></figure><p><strong>How to implement?</strong></p><p>For each test run, record the date and time of test start and end. Record only working days so that there are no inaccuracies due to weekends.</p><p><strong>How to use the metric?</strong></p><ol><li><em>Release Scheduling</em>. The metric allows you to accurately estimate how much time you need to test a new build and factor that into your release schedule.</li><li><em>Identifying areas for improvement</em>. If testing time is growing, it may indicate problems: insufficient automation, high task complexity, or lack of resources.</li><li><em>Finding outliers</em>. Analyzing data helps you find outliers and understand their causes — whether it’s delays due to complex bugs, insufficient test coverage, or failures in the testing process.</li><li><em>Evaluating the effectiveness of changes</em>. Metrics help you evaluate the impact of implemented improvements (such as automation or process changes) on testing speed.</li></ol><p>There are plenty of other valuable metrics beyond these three, but these are some of the rare ones that can be applied universally across projects, regardless of their specifics.</p><p>That’s it for now! Thanks for taking the time to read this article — I hope it provided useful insights and inspired you to refine your QA processes. Let’s make quality a priority, one metric at a time.</p><p>Bye, and happy testing!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d5ab4517e40" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Common QA Mistakes That Can Ruin Your Testing Process]]></title>
            <link>https://medium.com/@yuliashaifele/common-qa-mistakes-that-can-ruin-your-testing-process-38b1d1d0b134?source=rss-3e4009c513eb------2</link>
            <guid isPermaLink="false">https://medium.com/p/38b1d1d0b134</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[Yulia Shaifele]]></dc:creator>
            <pubDate>Tue, 26 Nov 2024 15:33:24 GMT</pubDate>
            <atom:updated>2024-11-26T15:33:24.036Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*8K9pyGQzHYGZeMp2wql6bA.png" /></figure><p>Software testing isn’t magic — it’s a craft. Even experienced testers sometimes make mistakes that can affect the quality of the product. What are the common pitfalls that QA professionals face, and how can they be avoided? Let’s break them down with real-life examples and practical solutions.</p><h3>Lack of Requirement Testing</h3><p>Requirements are often treated as sacred: they come in, and we start working. But what if they’re inaccurate from the start? Bugs emerge after the release, and fixing them feels more like firefighting.</p><p><strong>Example:</strong><br>You’re asked to test a registration form. According to the requirements, the name input field should only accept letters. You check it, and it works perfectly. But later, it turns out that a user named “Anna-Maria” cannot register, and your product manager is baffled: “Isn’t a hyphen a letter?”</p><p><strong>How to Solve It:</strong><br>Don’t be afraid to ask questions. The more details you clarify upfront, the fewer surprises will appear later.</p><h3>Skipping Automation</h3><p>When deadlines are tight, writing automated tests might seem like a luxury you can’t afford. But here’s the paradox: without automation, you’ll find yourself endlessly repeating the same tasks, like in the movie <em>Groundhog Day</em>.</p><p><strong>Example:</strong><br>Every week, you manually verify how the “Add to Cart” process works. It doesn’t seem too hard, but it takes an hour. After a couple of months, you realize these repetitive tests are eating up all your time.</p><p><strong>How to Solve It:</strong><br>Don’t shy away from automation. Write the test once, and you won’t have to think about the routine again.</p><h3>Ignoring UX Testing</h3><p>You’ve checked everything against the checklist, and the product works flawlessly. But suddenly, users get lost in the interface, can’t find the right button, and… leave for competitors.</p><p><strong>Example:</strong><br>You’ve tested the interface for hotel booking. The functionality is perfect, but users complain that the “Book Now” button blends into the background and is hard to find.</p><p><strong>How to Solve It:</strong><br>Look at the interface through the eyes of the user. Test scenarios like “I don’t understand anything” and “Where do I make a purchase?”</p><h3>Relying on Perfect Test Data</h3><p>If you always test with perfect data, expect surprises in production. Real users won’t input “John Doe” and a flawless phone number. Their data will be messy and full of unexpected cases.</p><p><strong>Example:</strong><br>Your tests show that the form processes data perfectly. But as soon as a customer enters a phone number with spaces or an extra character, the system crashes.</p><p><strong>How to Solve It:</strong><br>Use realistic data. Your tests should include unexpected spaces, strange characters, and even typos.</p><h3>Ignoring Console Errors</h3><p>The scenario: the product works visually, but the console is full of red flags. You ignore them, and a couple of months later, they turn into a disaster.</p><p><strong>Example:</strong><br>You’re testing a landing page. Everything looks great, but the console keeps showing errors like “Uncaught TypeError.” A month later, the landing page stops working due to a bug in the old code.</p><p><strong>How to Solve It:</strong><br>Don’t ignore the console. It’s like warning lights on your car dashboard, signaling that something needs attention.</p><h3>Misunderstanding Your User</h3><p>A product designed for everyone often ends up being suitable for no one. Don’t try to please everyone; instead, understand who your target audience is and what they care about.</p><p><strong>Example:</strong><br>You’re testing an app for senior citizens, but the developers included tiny fonts and complex navigation. The result: older users can’t figure it out and go back to paper-based solutions.</p><p><strong>How to Solve It:</strong><br>Consider the needs of your audience. Use larger fonts, increase text contrast, and simplify navigation to make key features easily accessible. Test the app with representatives of the target audience to identify pain points and adjust the design before release.</p><h3>Narrow Test Coverage</h3><p>Happy path scenarios are great, but real life isn’t limited to smooth journeys. People click the wrong things, input unexpected data, and do things you never anticipated.</p><p><strong>Example:</strong><br>You tested the login process, and it works perfectly. But when a user enters a space in the email field, everything breaks.</p><p><strong>How to Solve It:</strong><br>Don’t limit yourself to the main scenario. Add tests for edge cases, input errors, and unexpected behaviors.</p><p>Testing isn’t just about checking if the program works. It’s about caring for the product’s future, its users, and your reputation. The earlier you catch problems, the less likely they are to affect someone else’s experience. Work smart, test with passion — and let your tests be perfect (or at least close to it)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38b1d1d0b134" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web application test cases using a sniffer: Proxyman examples]]></title>
            <link>https://medium.com/@yuliashaifele/web-application-test-cases-using-a-sniffer-proxyman-examples-7deef4aac177?source=rss-3e4009c513eb------2</link>
            <guid isPermaLink="false">https://medium.com/p/7deef4aac177</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[test-case]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <dc:creator><![CDATA[Yulia Shaifele]]></dc:creator>
            <pubDate>Mon, 11 Nov 2024 16:18:45 GMT</pubDate>
            <atom:updated>2024-11-11T16:18:45.818Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Iwtn4MsMkpLsXvYAL6tRRA.png" /></figure><p>When I first started working as a tester, traffic sniffers seemed something far away to me. I had something in my head like, “Well, it’s for mobile testers and developers. I don’t need it.” But then I gradually started to use them and realized that a sniffer is a mast have thing in some cases!<br>In this article I will tell you about several cases where traffic sniffers can really save a lot of time and some nerves. Let’s go!</p><h4>1. How to catch error 500 without crashing the server</h4><p>Sometimes you want to test how an application will react to error 500 or 403. But you don’t want to crash the server for that, do you? Or wait for someone to create a special account with permissions for 403? Sniffer comes to the rescue!<br>What we do:<br>1. Open the sniffer, create a rule in Map Local with the name “Error 500 Emulation” and enter the desired URL.<br>2. In the response field we write: <em>HTTP/1.1 500 Internal Server Error</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qTOFepwGoV9s9V3zj9repw.png" /></figure><p>3. Save the rule and check that everything is working as it should on the frontend:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L_8yvxG_4l28UwrHUHi6vw.png" /></figure><h4>2. Redirecting Traffic Instead of Waiting for Developers</h4><p>Sometimes you need to test right now, not a week later when developers compile a new version. You want to redirect traffic to another backend branch yourself. The sniffer helps again!</p><p>Here’s how we proceed:</p><ul><li>Create a rule in Map Remote named “<em>Redirect to New Server</em>”</li><li>In the “URL” field, enter the current address where all requests are sent</li><li>In the “Host” field, enter the new server where the requests should go</li><li>Save, and you’ll see that your requests are going where they need to without the developers’ help</li></ul><h4>3. Substituting Responses from Third-Party APIs</h4><p>Need to test how your application works with different responses from external services, but don’t have access to them in the test environment? No problem! Replace the response with a sniffer and enjoy.</p><p>Example: Check how the application handles service unavailability. Substitute the API response with a 503 Service Unavailable and see if the application’s logic works correctly.</p><h4>4. Checking for blank page state</h4><p>Sometimes, you might need to spend a lot of time deleting data through the database or API just to see how an empty list or table appears. A sniffer allows you to do this in just a couple of clicks. Let’s explore this case using the example of orders on the LEGO website.</p><p>Here’s the initial state of the page when the user already has some orders:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*crSQuySYi1als8ddoOkl5g.png" /></figure><p>Now let’s check how the page looks without any orders. To do this:</p><ol><li><strong>Capture the request</strong> that returns the list of orders.</li><li><strong>Right-click</strong> on the request and select: <strong>Tools &gt; Breakpoint &gt; Save</strong>.</li><li><strong>Perform the action</strong> on the site that triggers this request. A window with the “captured” request will open.</li><li><strong>Execute the request</strong> since we don’t need to change anything in the request itself.</li><li>In the next window, <strong>open the response body</strong> and <strong>delete the data</strong> of all records. The screenshot below shows exactly what needs to be deleted:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VTtvFuKjYpiljL4RkN3ncA.png" /></figure><p>After sending the modified response, revisit the page. Now, an empty state with a placeholder is displayed. Here’s how it looks:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WujAxWoYWzQOu96iqDsElA.png" /></figure><h4>5. Testing Object States</h4><p>Suppose we have an order with the status “Cancelled,” but we want to see what happens with other statuses. Instead of asking developers or waiting for server changes, we change the status directly in the sniffer. In the screenshot below, you can see that we have an order with the status “Cancelled”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*h-4xvDcReRKgiP_3djibpQ.png" /></figure><p>Here’s what we do:</p><ol><li><strong>Capture the request</strong> that contains the order data.</li><li><strong>Change the status</strong> from “Cancelled” to “Just placed”.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/618/1*DBQEXxc3wKp6xnY3cAKYuQ.png" /></figure><p><strong>3. Send the modified request</strong>. Now, the page displays the new order status and the corresponding message. Here’s how it looks:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*c0MWqiE63zcrWGigNQ9EpQ.png" /></figure><p><strong>Additional Cases</strong></p><p>Here are a few more useful scenarios for using a sniffer:</p><ul><li><strong>Testing Timeouts and Slow Connections</strong>: Emulate delays to check how the application handles them.</li><li><strong>Testing Pagination</strong>: Quickly substitute responses to see how pagination works.</li><li><strong>Substituting Request Headers</strong>: Change the User-Agent or Accept-Language headers to test content display for different devices and languages.</li></ul><p><strong>Conclusion</strong></p><p>Traffic sniffers are not just for developers and mobile testers. They are powerful tools that can help in the most common cases. If you haven’t used sniffers in your projects yet, now is the time to start!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7deef4aac177" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Speeding Up Development and Testing with DevTools: 4 New Features That Will Save You Time]]></title>
            <link>https://medium.com/@yuliashaifele/speeding-up-development-and-testing-with-devtools-4-new-features-that-will-save-you-time-44c87e2e8e09?source=rss-3e4009c513eb------2</link>
            <guid isPermaLink="false">https://medium.com/p/44c87e2e8e09</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[debugging]]></category>
            <dc:creator><![CDATA[Yulia Shaifele]]></dc:creator>
            <pubDate>Tue, 29 Oct 2024 18:33:07 GMT</pubDate>
            <atom:updated>2024-10-29T18:38:43.271Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*2_U61enSIy3cHUKV0WsK-A.png" /></figure><p>Debugging and testing have always been integral parts of my work, but let’s be honest — they can be downright tedious and a major time sink. Lately, though, I’ve come across four <strong>brand-new features in DevTools</strong> that have genuinely transformed how I approach these tasks. These tools are designed to simplify the routine aspects of debugging and performance analysis, and they’ve made my workflow so much more efficient. I’m excited to share them with you because I believe they’ll make a real difference in your development process too. Let’s dive in and explore how they can help you save time and work smarter.</p><p><strong>1. Inspecting Elements Without Losing Focus</strong></p><p>It often happens: you need to test a dropdown menu or another interactive element, but it disappears as soon as you open DevTools. This occurs because the page loses focus, but now there’s a solution in DevTools.</p><ul><li><strong>Problem:</strong> Elements disappear when you try to inspect them, making it difficult to verify them.</li><li><strong>Solution:</strong> Enable the new <strong>Emulate a focused page</strong> option on the <strong>Styles</strong> tab so that the page always remains in focus.</li><li><strong>How to enable:</strong> Go to the <strong>Styles</strong> tab, find the <strong>Emulate a focused page</strong> option, and activate it. The setting will stay enabled, so you won’t have to repeat these steps every time.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/518/0*-Adgtwz8Rc6F-9vS" /></figure><p>This option saves time and makes testing disappearing elements easier — you won’t have to come up with workarounds anymore.</p><h3><strong>2. Quick AI Assistance for Console Errors</strong></h3><p>Console errors are a familiar pain for every tester. They can appear in the most unexpected places, and it can be difficult to understand where they’re coming from. Now, DevTools helps sort out errors using built-in AI that immediately suggests possible solutions.</p><ul><li><strong>Problem:</strong> Console errors that are hard to trace.</li><li><strong>Solution:</strong> Click on the lightbulb icon next to the error, then click <strong>Continue</strong> to start the AI analysis. It will generate possible causes of the problem and offer solutions, speeding up the error resolution process.</li><li><strong>Note:</strong> If the AI’s suggestion doesn’t fit, you can always use the built-in search for additional solutions.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/0*JdNZELQKo2Tf0c9I" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/0*QDP-ZI1Jbw0JPOLm" /></figure><p>This feature is especially useful for analyzing recurring errors, such as undefined, and saves a lot of time on debugging.</p><h3><strong>3. Real-Time Performance Monitoring</strong></h3><p>A new performance panel has appeared in DevTools, which greatly simplifies work. Now you can track key metrics like Core Web Vitals right during testing — and most importantly, immediately see how the site behaves for real users. This is a real helper for testers: you not only see what’s happening on your end but also get a picture of how the site works “in the field.”</p><ul><li><strong>What the new panel can do:</strong> Shows real-time performance metrics and allows you to compare them with user data.</li><li><strong>How it works:</strong> Metrics are updated automatically and highlight problem areas in color so you can respond quickly.</li><li><strong>Why you need it:</strong> Comparing local data with real user metrics helps you immediately see if the site works slower for them than for you. This makes it easier to find problem spots and improve the site’s performance for everyone.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/0*rQtlhnLtNVY83KxT" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/797/0*aagDwPaUOcGpUViq" /></figure><p>This new panel is an excellent tool for quick testing and analysis. With its help, you can instantly understand where performance is lost and quickly fix everything so that the site pleases not only you but also your users.</p><h3><strong>4. Mocking API Responses</strong></h3><p>When the backend isn’t ready yet but you already need to test the interface, the new <strong>Network Overrides</strong> feature in DevTools saves the day. It allows you to create fake API responses so you don’t interrupt the testing process and don’t depend on the server’s readiness.</p><ul><li><strong>When to use:</strong> If you’re testing the interface and the API isn’t ready yet.</li><li><strong>Solution:</strong> With <strong>Network Overrides</strong>, you can substitute the API response.</li></ul><h4><strong>How to use:</strong></h4><ol><li><strong>Find the required request in the Network panel:</strong> In DevTools, open the <strong>Network</strong> tab and find the API request you want to override.</li><li><strong>Right-click on the request:</strong> Click the right mouse button on the request and select <strong>Override response</strong>.</li><li><strong>Modify the data:</strong> In the window that appears, edit the response. Enter or paste the data you want to pass to the interface.</li><li><strong>Save changes:</strong> Save the new data (<strong>Ctrl + S</strong>) so that DevTools remembers the overridden response.</li><li><strong>Refresh the page:</strong> Reload the page to run the API request again and see how the interface reacts to the overridden data.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/0*9iPx9LXD7IM-7TR1" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/841/0*12lhezH_QmgfxrtV" /></figure><p>This feature is especially convenient for teamwork. Overridden files can be saved and synchronized with colleagues so that everyone has the same test data and doesn’t have to wait for the backend to be ready.</p><p><strong>To Sum Up</strong></p><p>These new DevTools capabilities will help you not only speed up your work but also make testing and debugging more flexible and precise. Now you have tools that:</p><ul><li>Simplify element inspection without the risk of them disappearing,</li><li>Provide AI-powered console error suggestions,</li><li>Allow you to monitor performance and see how the site works for real users,</li><li>And simulate API responses so you can test the interface even if the backend isn’t ready yet.</li></ul><p>With these features, DevTools becomes a full-fledged set of tools for quick and effective testing, reducing time spent on routine tasks and allowing you to focus on the main thing — ensuring stable and high-quality product performance.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44c87e2e8e09" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>