Daniel Moka’s Post

There is never enough time for testing, right? Given that testing time (or time for writing automated tests) is limited, where should you focus your efforts? Every change to a code base has the chance to introduce new bugs. And while code that is in production very likely still has bugs as well, it seems like a good strategy to focus on testing the new and changed parts of your code base first. Similarly, code that is covered by your (automated or manual) testing is probably not bug free, as there is only so much you can do with testing. However, for the code that was not tested at all, you can be sure that you will spot bugs only by luck. Intuitively, focusing on code that was changed, but not yet tested, seems like a good strategy to focus testing efforts on. But how good is this strategy? Luckily there is a study to answer this question (link in the comments): changed but untested code is up to 5 times more likely to contain a bug! Does this match what you are already doing? Do you have other strategies for distributing your test efforts? 

💡 Why Not Make All Methods Static in Your Automation Framework? If you’ve ever wondered, “Why can’t we just make everything static in our automation testing framework?” — you’re not alone. At first, it might seem easier and more straightforward, but here’s why that approach can backfire: 🚫 You lose flexibility. Frameworks thrive on reusability and modularity. Static methods can’t maintain instance-specific states, making it hard to adapt to changing requirements or parallel tests. 🚫 Shared state issues. In multi-threaded environments, static methods can lead to unexpected bugs because they don’t handle test-specific data well. 🚫 Bye-bye, design patterns. If you’re using the Page Object Model (POM) or other OOP-based designs, static methods don’t fit. Pages and test actions are best managed as objects, not static classes. 🚫 Mocking nightmares. Testing and debugging static methods isn’t fun. Mocking static methods (e.g., with Mockito) adds unnecessary complexity to unit tests. ✅ When are static methods okay? For utilities like random data generators, Excel reading,logging, or constants—static is perfect. Just don’t use them for everything. 💬 What do you think? Do you agree, or have you tried a different approach in your frameworks? comment out please #AutomationTesting #Selenium #SoftwareTesting #TestAutomation #LinkedInLearnin

Unveiling the Truth: The Power and Perils of Unit Testing: Recently, I have been working a lot on unit tests, and one thing keeps bugging me: is it really worth the time to spend on unit tests? Should it really be the norm to do unit testing? And while thinking about it, I got to the internet and searched it; turns out I am not the only one. So one thing comes to my mind: What are the actual purposes of unit tests? Are they just a gimmick? Currently, the focus of unit testing has become to cover certain coverage percentage rather than having meaningful tests. Although percentages do reflect the status of tests, covering less than specified percentage should not be considered out of this world. The priority should always be meaningful tests rather than trying to spend every minute figuring out how to increase a small percentage so that they can be considered 'approved.' Furthermore,  we use these tests to guide specific situations, but it's unrealistic to think we can predict every mistake or path a user might take. This is one of the reasons why some big tech companies don’t do unit tests because just like everything, sometimes the cost does exceed the benefits. On the contrary, unit tests do have some benefits. Every application has dark corners, known best by developers. Unit tests can cover these corners ensuring stability of applicaton. Every Developers should also consider it a healthy thing rather than just a chore that takes up their time, they should accept it as a great tool for uncovering errors. In short, in my opinion, the value of unit testing depends greatly on the type of project and how good the test are written. When used wisely in the right project, it can be a great asset, not just a checkbox to tick.

Looking out for tips on "Writing an Effective Unit Test"? (Last one is really important) There are few ways of writing effective unit tests, and for me this one stood out The "FIRST" Principle Let me explain the "WHY" 1. F → FAST - Test should be fast. - Test the smallest possible "logical" piece of code. - Test should run quickly at any development cycle. 2. I → Isolated and Independent - Test should arrange its own data. - Test should not depend on external data. - Neither rely on prev test or order of execution of others. 3. R → Repeatable - Multiple times test run → Same result. - Test should either pass or fail until fixed in every environment. - Make sure test is not affected by order or number of callings on it. 4. S → Self Validating - If you can't rely on the test → Don't run it. - Should clearly indicate whether it passes or fails. - Use testing frameworks to ensure issue reporting done right. 5. T → Thorough and Timely - Should aim for maximum code coverage - Should be timely or written when you write the code - Happy Path → Edge Cases → Exceptions → Nonfunctional requirements Remember FIRST principle provides a solid foundation for "good" unit test (Share ♻️ with your friends who is exploring #unittesting) P.S. Which one in FIRST did you like the most? #softwareengineering

Most people, myself included, don’t remember the exact code they wrote a week after finishing it—unless it was either exceptional or exceptionally awful. But at the end of the day, what really matters isn’t the code itself, it’s whether it works! And I prove that to myself and to others with unit tests. In fact I feel strongly that pull requests should be rejected without solid unit testing validation of the tasks acceptance critera. Personally, I find it hard to process hundreds of lines of code in one go, but give me a well-written unit test with clear intent, and I can immediately see if it proves that the code meets the acceptance criteria. Naming your tests with business rules in mind is key to this. Forget about the internal workings—they’ll likely change over time. The requirements? Probably not. This approach is especially useful in #TDD, where staying focused on what the code needs to do is far more important than how it’s doing it. If you’re struggling to phrase a test in business terms, it’s probably a sign you’re adding something unnecessary. Build with this in mind, and you’ll ensure your code is not just passing tests, but delivering real value. For more info on the topic let me suggest Testing: Principles, Patterns and Practices by Vladimir Khorikov. But first I’d recommend reading his post on test naming to get a taste of how on point and practical his thinking is. There is a link in there that can get you a tastey discount (though it’s a bit old. Vlad, does it still work?) https://lnkd.in/gyCFQ98U

Simple example of unit testing. The good way and bad way. Problem: A blogger wants to send notifications about his new posts to website visitors. Solution: - Allow visitors to subscribe to the mailing list - Send an email to the subscribers when a new post publish Bad unit tests (Test implementation) - Storing subscribers (Testing individual methods ex: Repository.save()) - Get Subscribers (Testing individual methods ex: Repository.get()) - Sending email (Testing email gateway) Good unit tests (Test behaviors) - Visitor subscribes to the mailing list (Testing emails added to a mailing list. Uses both get and save repository interfaces) - New post is published, notify the mailing list (Given subscribed emails, When the new post is published. Subscribed emails receive the post) Behavior tests cover multiple classes and methods. The target is to cover primary and alternative paths of the use cases. Note: You don't have to mock interfaces either. You can use test-specific sub-classes or humble objects to test the whole process.

🚀 𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠 𝐖𝐡𝐢𝐭𝐞 𝐁𝐨𝐱 𝐚𝐧𝐝 𝐁𝐥𝐚𝐜𝐤 𝐁𝐨𝐱 𝐓𝐞𝐬𝐭𝐢𝐧𝐠: 𝐄𝐬𝐬𝐞𝐧𝐭𝐢𝐚𝐥 𝐟𝐨𝐫 𝐂𝐨𝐦𝐩𝐫𝐞𝐡𝐞𝐧𝐬𝐢𝐯𝐞 𝐐𝐀! 🧑💻🔍 Hey LinkedIn Family!🔗 In the world of software testing, two fundamental approaches ensure we deliver high-quality products: White Box Testing and Black Box Testing. Let's dive into what they are and why they matter. 🔍 𝐖𝐡𝐢𝐭𝐞 𝐁𝐨𝐱 𝐓𝐞𝐬𝐭𝐢𝐧𝐠: Also known as clear box, glass box, or structural testing, White Box Testing involves testing the internal structures or workings of an application. - 𝐊𝐞𝐲 𝐂𝐡𝐚𝐫𝐚𝐜𝐭𝐞𝐫𝐢𝐬𝐭𝐢𝐜𝐬: - Insight Required: Deep knowledge of the internal code structure. - Focus Areas: Internal logic, code paths, and design. - 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞𝐬 𝐔𝐬𝐞𝐝: - Statement Coverage: Ensures every line of code is executed. - Branch Coverage: Tests every possible path in the code. - Path Coverage: Examines all potential paths through the code. - Data Flow Testing: Monitors variable usage throughout the code. - 𝐀𝐝𝐯𝐚𝐧𝐭𝐚𝐠𝐞𝐬: - Identifies hidden errors and security vulnerabilities. - Optimizes performance by uncovering inefficient code. - Thorough validation of the software’s internal workings. - 𝐃𝐢𝐬𝐚𝐝𝐯𝐚𝐧𝐭𝐚𝐠𝐞𝐬: - Requires access to source code. - Can be time-consuming and complex. - 𝐓𝐲𝐩𝐢𝐜𝐚𝐥 𝐔𝐬𝐞 𝐂𝐚𝐬𝐞𝐬: - Unit testing by developers. - Code optimization and security testing. 🔍 𝐁𝐥𝐚𝐜𝐤 𝐁𝐨𝐱 𝐓𝐞𝐬𝐭𝐢𝐧𝐠: Also known as behavioral or functional testing, Black Box Testing focuses on testing the software’s functionality without any knowledge of its internal workings. - 𝐊𝐞𝐲 𝐂𝐡𝐚𝐫𝐚𝐜𝐭𝐞𝐫𝐢𝐬𝐭𝐢𝐜𝐬: - Insight Required: No need to understand the internal code. - Focus Areas: Input/output validation, user interface, and functionality. - 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞𝐬 𝐔𝐬𝐞𝐝: - Equivalence Partitioning: Reduces test cases by dividing inputs into groups. - Boundary Value Analysis: Focuses on edge cases. - Decision Table Testing: Tests rules and logic using tables. - State Transition Testing: Tests different states and transitions. - 𝐀𝐝𝐯𝐚𝐧𝐭𝐚𝐠𝐞𝐬: - Tests from the user’s perspective, ensuring requirements are met. - Easier to create and execute without needing access to the source code. - 𝐃𝐢𝐬𝐚𝐝𝐯𝐚𝐧𝐭𝐚𝐠𝐞𝐬: - May miss defects in the internal structure. - Limited by the lack of internal view. - 𝐓𝐲𝐩𝐢𝐜𝐚𝐥 𝐔𝐬𝐞 𝐂𝐚𝐬𝐞𝐬: - Acceptance testing. - System testing. - Regression testing. - End-to-end testing. 📢 𝐉𝐨𝐢𝐧 𝐭𝐡𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧:💻🔧 Which testing approach has brought you the most success in your projects? Share your thoughts and experiences in the comments below! #SoftwareTesting #WhiteBoxTesting #BlackBoxTesting #QualityAssurance #QA #TestAutomation #SoftwareDevelopment #UnitTesting #FunctionalTesting #TechCommunity #SoftwareQuality #DevOps #TestingTools #TechInsights #CodingLife #TechTalk

1. Write a program to find duplicate elements in a string array. 2. How would you introduce yourself briefly and effectively? 3. Explain the framework you have worked with in your automation testing process. 4. How do you handle closing the second window of a browser in automation testing? 5. Differentiate between XPath and CSS selectors. 6. What is the syntax for a LinkText XPath locator? 7. What changes or setups do you perform before starting execution in your framework? 8. How do you handle change requests in your application? Describe the steps you follow. 9. How often do you trigger regression test scripts? How do you manage them in your repository? 10. What challenges have you encountered in automation testing, and how did you overcome them? 11. Explain the differences between GET and POST methods in API testing. 12. What are the essential components of the GET and POST methods? 13. Discuss HTTP status codes like 401 and 503. 14. How do you validate the response code in API testing? 15. What format do you use for assertions in your tests? 16. Explain the difference between 200 and 201 HTTP status codes. 17. Provide the syntax for query parameters in API requests.

If you’re a newcomer in the world of testing, you easily become overwhelmed by all the testing terminology getting thrown around. For example, what is the difference between automated and manual testing? And what is a test script vs test case? In this article, we’ll try to explain some of the jargon you might encounter in your daily testing life, just to make it all a little bit more understandable. 1. Test cases (instructions to validate software functionality), 2. Test suites (grouping of test cases for organization), and 3. Test runs (determining which test cases to run by users at specific times), Read more at: