<?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 Marcin Ludzia on Medium]]></title>
        <description><![CDATA[Stories by Marcin Ludzia on Medium]]></description>
        <link>https://medium.com/@marcin.ludzia_84671?source=rss-16061b447488------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ffNZVR7loCetfE14i6axRA.jpeg</url>
            <title>Stories by Marcin Ludzia on Medium</title>
            <link>https://medium.com/@marcin.ludzia_84671?source=rss-16061b447488------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 02:48:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@marcin.ludzia_84671/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[How to teach TESTERS programming?]]></title>
            <link>https://medium.com/c-f-data-driven-innovators/how-to-teach-testers-programming-53d300152e5e?source=rss-16061b447488------2</link>
            <guid isPermaLink="false">https://medium.com/p/53d300152e5e</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[automation-testing]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[Marcin Ludzia]]></dc:creator>
            <pubDate>Thu, 02 Jun 2022 12:05:29 GMT</pubDate>
            <atom:updated>2022-06-02T14:26:35.756Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GneZFwawf9kDCsdeHKqxkw.png" /></figure><p><strong>What does a manual tester do to start testing automatically? They learn programming, of course. However, without experience with coding, this road can be bumpy. I often see that understanding such programming concepts as code split into classes and methods, parameters references, or basics of OOP may be hard to understand at the beginning. But they are crucial.</strong></p><p>If you have encountered these bumps, and are looking for a way to avoid them, explore the educational roadmap I prepared for an effective and comprehensible process of teaching testers how to code.</p><h3><strong>How do testers differ from programmers?</strong></h3><p>Writing automated tests, simply put, is developing software that tests other software<strong>*</strong>. But developers and testers develop their code in different ways. <br>There are three key differences:</p><ol><li><strong>Point of view (perspective)</strong></li></ol><p>For starters, developers and testers usually have different points of view. And that’s good, because they complement each other. While developers usually want to make the functionality work, testers focus on making sure that all users’ needs are met, and the software remains resilient to different, even exotic, users’ inputs or application use. As you can read in my other article, <strong><em>How to develop quality software in agile</em></strong>, in the case of application quality, developers usually focus on code quality. Testers, however, focus on the overall quality perception of the application as seen from the end user’s point of view.</p><p><strong>2. Code dependency and structure</strong></p><p>The second difference is in the code that developers and testers write. The application’s code is architecturally independent from the tests code. On the other hand, test code is architecturally dependent on application code. This means that tests follow the application. This is particularly evident in lower-level tests, but also visible in end-2-end tests.</p><p>Another aspect is that tests should be easy to implement. They should not involve any business logic. Checking different business cases should be implemented as separate tests, or as different test data cases for the same script. So, all tests should be implemented in a straightforward manner.</p><p><strong>3. Required skills</strong></p><p>The third difference is obvious. As a rule of thumb, to start working on tests automation, you need to know fewer programming concepts compared to application development. But this may be tricky. You may think that you will be fine with only a basic understanding of programming. This assumption usually gets verified quickly.</p><p>But at the same time, you don’t what to go through the whole Computer Science program with Assembler, Algorithms and Data Structures, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/904/1*KtHZqpavUgbP6SaLUSuW-g.png" /></figure><p>So how to properly balance the need to quickly put people to work on test automation with giving them enough background so they will be able to further develop themselves as programmers? <br>Here is my recipe.</p><h3><strong>Roadmap for programming skills for testers</strong></h3><p>There are different programming languages and different strategies; e.g., I can see the rising popularity of JavaScript in automated tests. However, I think that Java is the language best suited for the purpose (at least for now) — especially in bigger, corporate projects. And according to Angie Jones’s statistics<strong>**</strong>, Java is still the first choice for test automation. But Java might be overwhelming at the beginning, when you need to declare a class (what is a class??), and a static function (what is static, and why?) just to display “Hello World!”. Also, the toolchain around Java might be a bit complicated for newbies.</p><p>So, we will start with Go — a simple language with a great toolchain, and some aspects that will make teaching yourself Java later easier. Then we will move to Java, the target language.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cxv6EmRCISnlPEJbsrqGsQ.png" /></figure><h3><strong>Go</strong></h3><ol><li><strong>Data types and data manipulation</strong></li></ol><p>The purpose of this lesson is to show native data types, such as int (and variants, like int64, uint64, etc.), float32, float64, bool, rune, and string. The learner will need to understand different kinds of data that can be stored in different data types. It is also crucial to understand what happens if you exceed the maximum value that can be stored in a certain variable (e.g. what happens if you add 1 to int8 variable with an actual value of 127), and that float numbers cannot represent all values correctly (e.g., 0.2 is rounded, and cannot be represented precisely).</p><p>As an additional bonus, it is good to introduce a very basic pointer syntax to show what is held inside: variable, <strong>*</strong>pointerToVariable, pointerToVariable, &amp;addressOfVariable. You can show everything in a simple <em>hello world</em> program followed by equally simple examples of different variables and pointers to show what is possible and what is happening under the hood in the computer’s memory.</p><p><strong>2. Flow control</strong></p><p>This is the foundation. In imperative languages, statements to make decisions or to repeat certain instructions are at the heart of programming. The good news for students is, these statements work the same (or are very similar) in all imperative languages. So, during this lesson, you will want to demonstrate and teach conditional statements and loops.</p><p><strong>3. Functions</strong></p><p>In the third lesson, the first difficult topic is introduced. Understanding the division of a program into functions, the mechanics behind how functions/methods call each other, and how they pass control and pass data (as parameters and return values) is crucial. It is good to once again use pointes to show how parameters are passed (with passing by value and passing a pointer).</p><p>But the truly difficult part for people who are learning to code is related to how they should divide a program into smaller chunks. This is not language semantics. This is about the principle of writing small, reusable functions. And I know that this might be difficult at first. And you need to spend some time practicing this. It’s worth it.</p><p><strong>4. Tables and structs</strong></p><p>The next topic is related to basic data structures. The main objective here is to teach how different variables can be grouped and used as single collection.</p><p>First, you need to show how a table can be declared and used to store different amounts of data of the same type. After that, you need to present the concept of the struct. This one is particularly important because it teaches many things before we move fully to Java — a classic Object-Oriented language. First, structs can help the learner think of grouping different types of data into larger entities. And because of the Golang semantics, it also teaches that this is in fact a new type (something that might not be as clear in Java at first, when you create a class). Teaching how to create and use structs also lays down foundations that will be crucial later, when learning Java.</p><p><strong>5. Unit test</strong></p><p>This is the first time the learner meets automated tests. In Go, unit tests are very easy to write, and you don’t need additional tools. Everything is built into the toolchain of Golang. At this point, you want to teach testers basic rules: what an automated test actually is, the basic structure of automated tests (e.g., via the triple A principle — Arrange, Act, Assert), how assertions/checks are used to obtain the test result. Unit tests are also great for the introduction of such concepts as test coverage.</p><p>Once again, while Golang here may not be as advanced as some libraries (e.g., AssertJ from Java), yet because of its simplicity, it really shows how it all works under the hood.</p><h3><strong>Java</strong></h3><p><strong>6. The basics of Java</strong></p><p>After the first five lessons in Golang, we move to our target programming language, which is Java. The first lesson about Java will be mostly the repetition of concepts already learned in Go, but with Java syntax. So, you will want to once again present primitive data types, flow control instructions, tables, etc. You don’t need to introduce the full concept of class yet, as this will be covered in a couple of following lessons.</p><p>The repetition of concepts that are already known has one more advantage. This makes students once again rethink everything they know. In my opinion, and from what I can observe, getting those fundamentals right is vital for understanding further topics. So, it’s good to encourage students to write some small projects with the knowledge they already have.</p><p><strong>7. Classes and Object-Oriented Programming</strong></p><p>It is the middle of the programming course, so it’s a good time to introduce and explain the concept of Object-Oriented Programming. This lesson should be mostly theoretical. But don’t provide full explanations on OOP yet. For now, focus on abstraction and hermitization: explain to your students how they should identify entities that are then translated into classes; how to encapsulate internal complexity, and provide only a public interface that can be used from outside the class. In practice, this translates into explaining the class syntax, constructors, and basic modifiers (private and public). For now, that will be sufficient. Give your students time to get used to thinking in an object-oriented way.</p><p><strong>8. Comments and the basics of clean code</strong></p><p>At this moment, students know the foundations of programming. Now it’s time to introduce some good practices. And this may seem trivial or obvious, but in my opinion it isn’t. Plenty of times I saw badly written code, with variables or functions improperly named, without any comments, or with too many comments. Or with comments that don’t give you a clue about how to use the code.</p><p>So, dedicate one lesson to explain in detail how to use comments. For both: explaining how the commented code works (documentation comments), and how comments can be used to design code (function or class). It is also important to provide some basic principles of clean code, naming conventions, code formatting, etc.</p><p><strong>9. Operations on Strings</strong></p><p>This is one of the most important lessons in the whole course. Operations on strings are essential and commonly used in test automation. By this lesson, learners will probably have had a chance to already compare two strings, concatenate strings with the “+” operator (in different configurations, e.g. String + String, String + Integer, etc.).</p><p>Now is the time for more advanced operations. So you want to start with easy methods, like: charAt(), contains(), endsWith(), startsWith(), substring(), toLowerCase(), toUpperCase(), trim(). Then you will want to work with more advanced cases and the use of split(), replace(), and replaceAll() methods. It would be also useful to show some examples of how to use those methods with simple regex expressions.</p><p><strong>10. Time and Date API</strong></p><p>Next is the time for the time and date API 😊. Dates and time are commonly used in applications, so a tester needs to know how to create and manipulate these objects. And in Java you need to have a good introduction to the time and date API. Since Java has two time and date APIs, you need to specifically show which class is from which version. Because you can find many examples on StackOverflow using the old API, I often see practice tests mess up Date class objects with LocalDate class objects. So, pay close attention to specifically introducing Java 8+ classes: LocalDate, LocalTime, LocalDateTime, Period, Duration. When testing corporate applications there might also be a need to use ZonedTimeDate.</p><p><strong>11. Tables and basic collections API</strong></p><p>The next lesson is about collections. First, you should introduce arrays as an easy and quick way to store a list of values. The arrays, however, are rigid and cannot be easily extended. For this reason, the List interface and ArrayList collection should also be presented. There is probably no point in presenting LinkedList, as this would not be necessary to use in tests.</p><p>As an extension to the basic scope of this topic, the Set and Map interfaces are worth mentioning (HashSet and HashMap implementations).</p><p><strong>12. More advanced OOP</strong></p><p>It is time to introduce more advanced topics related to Object-Oriented Programming. During this lesson, you will want to teach about inheritance, interfaces, abstract classes, and polymorphism. These are advanced topics, and in my view, testers probably could live without them. Someone could say that a tester does not need to know polymorphism. My answer would be that in many cases, simple scripts can be developed without this knowledge. But in bigger projects, or with a more advanced user interface, advanced object-oriented concepts can be used to write reusable code for the Page Objects layer, to minimize the maintenance effort later. Anyone who has spent some time in the test automation business knows that minimizing maintenance costs is crucial.</p><p>So even though inheritance or polymorphism may look at first as something that testers don’t need, in fact, it’s good to practice them a bit. This will result in a better feeling of OOP and better code that is easier to maintain.</p><p><strong>13. Unit tests in JUnit/TestNG</strong></p><p>Once again during this course, we will dedicate a lesson to unit testing. This time in Java. Since we already covered some basics of the topic in Golang, the students will already be familiar with the theory behind it. This time you should focus on the specifics of Java unit testing and a selected assertions library. In my case, I focus on the use of TestNG assertions and annotations. Assertions are used to provide additional meta-data for tests.</p><p>From this perspective, this lesson is probably less a theoretical one about unit testing, but rather a very practical introduction to the selected library. Junit and TestNG are both good.</p><p><strong>14. Error handling</strong></p><p>It is almost the end of the course. However, there are still a couple of important topics to cover. The first one is exceptions and error handling. Students should be familiarized with the concept of checked and unchecked exceptions in Java. They should know which ones can occur during the execution of tests, which ones need to be handled and declared. Finally, they need to know how to properly create a try-catch block. And since assertions in tests can make the test code finish earlier than expected, try-with-resources can also be covered.</p><p><strong>15. Network programming</strong></p><p>This is the last lesson. Use it to introduce network programming in Java, especially the HttpClient, HttpRequest and HttpResponse classes. This is more of a theoretical introduction to programming network calls. However, it is very important that testers know some basics. In real life though, the tester would use libraries like RestAssured for 99,3%<strong>***</strong> of the cases.</p><p>The above plan consists of 15 topics, just like a typical one-semester course at university 😊. During this time, we start teaching testers programming with a bit of Golang (to begin without overwhelming boilerplate code), then we move to Java and demonstrate some aspects of the language most commonly used in tests. To put everything in the testing perspective, rather than only teach about language semantics, we introduce some unit testing and good practices in coding to promote best practices from the beginning.</p><p>Skills related to programming are just the beginning of the path for test automation engineers. The next steps would be to teach them how to use automation libraries (like Selenium, Playwright, RestAssured, etc.), a version control system (Git), and dive deeper into TestNG/Junit. Once the test automation engineer is familiar with all these bits and pieces, he/she can start working on a production system. And as always, what matters most is practice, practice, and more practice 😊.</p><p><strong><em>*</em></strong><em> A disclaimer here: if you noticed that I omitted unit tests, which are built into the production code, you are right. But even though unit tests are important and actually a basis for the testing pyramid, they are typically built by developers. And higher-level tests are usually built by testers, who for the most part look at the software from the end user’s perspective.</em></p><p><strong><em>**</em></strong><em> </em><a href="https://applitools.com/blog/language-software-test-automation/"><em>Top 5 Popular Programming Languages for Test Automation of 2019 (applitools.com)</em></a></p><p><strong><em>***</em></strong><em> this is just my assumption. </em>😊<em> Not a real statistic.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53d300152e5e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/c-f-data-driven-innovators/how-to-teach-testers-programming-53d300152e5e">How to teach TESTERS programming?</a> was originally published in <a href="https://medium.com/c-f-data-driven-innovators">C&amp;F Data Driven Innovators</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Test automation engineer, the desired skillset]]></title>
            <link>https://medium.com/c-f-data-driven-innovators/test-automation-engineer-the-desired-skillset-a10ff7863bf8?source=rss-16061b447488------2</link>
            <guid isPermaLink="false">https://medium.com/p/a10ff7863bf8</guid>
            <category><![CDATA[skills-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[dream-job]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[test-automation-tools]]></category>
            <dc:creator><![CDATA[Marcin Ludzia]]></dc:creator>
            <pubDate>Tue, 08 Mar 2022 13:44:39 GMT</pubDate>
            <atom:updated>2022-03-08T13:44:39.496Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zUcB7CGU4pVaTN7EoPxCbw.jpeg" /></figure><p>In my last article, I <strong><em>wrote about how to develop good quality software in agile</em></strong>. In such an approach, test automation is essential. And at the same time, according to “<a href="https://www.katalon.com/resources-center/blog/infographic-challenges-test-automation/"><strong>Challenges in Test Automation: Survey Key Results</strong></a>”, 62% of survey respondents (mostly managers) agree that one of the top challenges in applying test automation is lack of skilled people. Many manual testers would like to start their journey with developing automated tests, however, without a good learning path and some technical background, the road seems to be a bit bumpy.</p><p>With this article I had two goals in mind:</p><ul><li>To help aspiring test automation engineers to plan their learning path,</li><li>To help managers set up development paths and promotion requirements within their teams.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nrs2NBNufy6J-3GxTt9fTg.png" /><figcaption>Commonly, we distinguish three levels of skills: junior, middle and senior, or — as I like to call them — foundation, professional, and master.</figcaption></figure><h3><strong>1.</strong> <strong>Test Automation Foundation</strong></h3><p>To start working on automating test scripts, one should have reasonable familiarity with programming tools, as well as decent knowledge of testing itself.</p><h4><strong>Programming</strong></h4><p>This is obvious, but to start developing an automated test you need at least basic knowledge of one programming language. I would recommend Java or JavaScript. JavaScript is easy to learn and easy to work with in smaller projects. It is a programming language for Cypress or Puppeteer. Java on the other hand is a mature programming language suitable for bigger projects. It is the most commonly used programming language in test automation now. Apart from the programming language, you need to know the basics of HTML and CSS. For bigger projects, you should also be familiar with GIT.</p><h4><strong>Theoretical testing</strong></h4><p>It is a no brainer that test automation engineers needs to know how to design tests. First of all, you need to know what tests are for and where to test. And this knowledge is not as easy to acquire as it might seem. Common certification is still propagating processes from 15 years ago. But since then, we have made some progress. So instead, I recommend reading about the agile testing process and approach. A good source is the <strong><em>Agile testing</em></strong> book by Lisa Crispin and Janet Gregory. You also need knowledge about black-box testing techniques, designing test cases, defining testing data, and of course, writing test reports and issuing bugs. To augment these must-have skills, there are two more that I’d suggest are worth acquiring. One is BDD (Behavior Driven Development) — an approach in which software is specified from the end-user perspective with the use of dedicated domain language, Gherkin. The other is the theoretical aspects of API testing. Since automating tests on the API level gives the best bang for your buck, knowing what it is and how to design API test is a good idea. For novices, I would recommend reading up on the VADER approach (Verbs, Authorization, Data, Errors, Responsiveness).</p><h4><strong>Technical testing</strong></h4><p>OK, now that you’ve made some preparations in programming and theoretical testing, it’s time to put it all together. For this, you need to know some test automation tools and/or automation libraries and testing libraries. As for test automation tools, I recommend you take a look at my previous article — <strong><em>Tools for test automation in 2022</em></strong>. As for the libraries, let’s start with ones used in automation. No matter what programming language you are using, the golden standard is Selenium (web browser automation). Having said that I myself am amazed by what PlayWright can do, so take this as an option. Next comes the testing library. And by that I mean a library that usually provides an extensive assertion library and a test runner. For Java, a good choice would be TestNG, while for JavaScript — Jest. The reality is, each programming language has its own library of choice.</p><p>Alternatively, if you choose to specialize in API test automation only, you can skip Selenium/PlayWright and take a good look at API testing libraries, like Rest Assured.</p><h3><strong>2.</strong> <strong>Professional Automated Tests Development</strong></h3><h4><strong>Theoretical programming</strong></h4><p>All right, so you have decent test automation skills and have some experience in the field. It’s time to take your game to the next level. First of all, spend more time on honing your programming skills. As a professional tester, you will be responsible not only for writing scripts but also for making more architectural decisions. You will also be helping younger teammates in guiding their code development. So, take time to arm yourself with an in-depth understanding of Object-Oriented Programming. Make sure you read such classic books as <strong><em>Clean Code</em></strong> by Bob Martin and <strong><em>Refactoring</em></strong> by Kent Beck. This is also a good time to familiarize yourself with the basics of software architecture and some design patterns.</p><h4><strong>Programming</strong></h4><p>With all that theoretical programming knowledge you may now go deeper with your programming language. For Java, for example, you should be able to use more advanced aspects, like streams API, lambda expressions, generics, etc. You should be also able to develop some basic operations on databases. This is useful mainly for test data seeding in the target environment. It is also good to know something about your Application Under Test. If you are testing a web application, where the front-end is written with the use of Angular or React, it is good to know some basics of these front-end frameworks, even just for adding automation IDs for elements.</p><h4><strong>Theoretical testing</strong></h4><p>In terms of testing, you already know most of the things. It is time to move a bit further beyond functional testing. As a professional test automation engineer, you should be aware of other types of automated tests: performance tests, load tests, security tests. At this level, it is also good to know different approaches to test automation, like Acceptance Test Driven Development, Keyword Driven Testing, Data-Driven Testing, etc. The idea behind this is that in test automation we usually need to select proper tools for the situation in which tests are developed. The broader your knowledge and context awareness, the better decisions you will make.</p><h4><strong>Practical testing</strong></h4><p>Since you already know most of the tools used for functional test automation, you need to learn how to use tools for non-functional testing. For performance and load testing, a good choice would be JMeter or Gatling. But the selection of particular tools depends on your preferences and project context: for analyzing web application code, I would recommend mastering Lighthouse.</p><h3><strong>3.</strong> <strong>Master your Test Automation skills</strong></h3><h4><strong>Theoretical programming</strong></h4><p>All right, so you have several years of experience in test automation, and you would like to master your craft. At this level, you should be able to perform more advanced programming tasks. To be able to do that, you will need some more advanced programming background. Most valuable will be design patterns and software architecture. For design patterns, you are probably already familiar with Page Object pattern, factory, facade, and a few more. Now it would be time to master other, more advanced ones. Also, it is the level where you should have a good understanding of software engineering, and especially the DevOps model. This background will give you a better understanding of the test automation context and will let you plan an automation strategy well.</p><h4><strong>Programming</strong></h4><p>As for programming tools, since you already know your programming language, it is time to go further towards DevOps tools, like Azure DevOps, Jenkins, etc. You should be able to build new pipelines and embed different automated tests in them. And since we are talking about DevOps, you should also be familiar with Docker. You should be able to build an image, and execute container or containerized applications (e.g., with Docker Compose).</p><h4><strong>Theoretical testing</strong></h4><p>The mastery level is all about awareness. So, in the testing field, you will no longer learn new things on the level of individual tests, but rather hone your skills on a higher level. Thus, you should be fluent in Continuous Integration and Continuous Delivery approaches, know how to best tailor tests for particular applications and situations. You should also be familiar with regulatory requirements that may apply to automated tests (if you are working in regulated industries).</p><h3><strong>4.</strong> <strong>Bottom line</strong></h3><p>There is one more thing you should learn. And this is the ability to observe, critique and change. Among all the skills mentioned above, you should be hungry for learning and constantly be looking for process optimization. This is not something you can learn from others. This is something you should learn from yourself. Pay attention to what you are doing and try to do it better next time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a10ff7863bf8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/c-f-data-driven-innovators/test-automation-engineer-the-desired-skillset-a10ff7863bf8">Test automation engineer, the desired skillset</a> was originally published in <a href="https://medium.com/c-f-data-driven-innovators">C&amp;F Data Driven Innovators</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to develop quality software in agile? Five important aspects of agile testing]]></title>
            <link>https://medium.com/c-f-data-driven-innovators/how-to-develop-quality-software-in-agile-five-aspects-of-agile-testing-that-i-find-important-cfb65c1da08a?source=rss-16061b447488------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfb65c1da08a</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Marcin Ludzia]]></dc:creator>
            <pubDate>Wed, 26 Jan 2022 12:32:00 GMT</pubDate>
            <atom:updated>2022-01-26T13:41:03.097Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-wKP5cmtjeAFlcuxQXFChQ.png" /></figure><p><strong>OK, it is 2022 and we have had the agile manifesto for more than 20 years now. It may seem like a long time. In 2001 there was Java 1.3 and .NET in version 2.</strong></p><p><strong>But somehow companies are still struggling with implementing the Agile approach to get quality software done right.</strong></p><p>You can even find articles on the Internet that suggest that agile and quality are opposites and you always have to choose one, or at least settle for a tradeoff of sorts. This <a href="https://about.gitlab.com/developer-survey/">GitLab report</a> reveals that as many as 56% of developers still perceive testing and quality departments as the main reason for slowing down the dev cycle. Another thing we can learn from the GitLab report is that in many projects, even though development as such is done “the agile way”, testing is still thumb-tacked to the tail end of the process, like an afterthought. Does this match your observations? It does mine.</p><p><strong>In this article, I want to share my observations on agility in testing processes.</strong></p><h3>1. Quality is everyone’s responsibility</h3><p>First of all, we need to understand and acknowledge that the quality of software is everyone’s responsibility. Everyone who participates in developing an application has an impact on the end product’s quality. And it doesn’t mean that there is actually no single responsible person ,or that the responsibility is diffused. It just means that to get quality software, we need to have good input from all parties involved. Good requirements, good design, good development, and good testing. We also need a well-established approach that promotes built-in quality. We need to know that quality starts at the conceptual stage.<br>Traditionally, testers or QA engineers are perceived as those responsible for quality. But this is a gross misperception. Testers can only verify if the final product is acceptable to end users, and if it has bugs — raise tickets for dev teams to remove these defects. In fact, we should perceive quality as something built into the process from the very beginning. Keeping high quality of all deliverables: from requirements analysis, through UX design, code quality, to the final product is what will bring the expected results in the end.</p><h3>2. Test early and test often</h3><p>In the agile approach to software development, it is crucial to test software as soon as possible and as quickly as possible. To keep this article short, I will not cover any aspects of testing other than testing working code (so I will not say anything about testing requirements, design, etc.).</p><p>In general, there are two facets of testing software. One is <strong>the code perspective</strong>, and the other is <strong>the user perspective</strong>.</p><ul><li><strong>The code perspective</strong></li></ul><p>Testing code is basically connected with building unit, integration, or component tests. There are all kinds of unit/integration/module tests that run in memory and test one or more parts of the application (method, class, component). Tests of this kind usually use additional infrastructure as mocks, test doubles, stubs etc. With such tests we can build a safety net for developers. Also, they are best suited to check the implementation of algorithms or business rules.</p><ul><li><strong>The user perspective</strong></li></ul><p>Traditionally, testing from the end user perspective was the main phase for the entire testing effort in waterfall projects. It was glued at the very end of the development process. However, in the agile testing approach, testing is built into the whole development effort. It should start at the same time as the development of new functionalities. For the user perspective, testers should start developing automated end-2-end tests. If the architecture of the application allows for that, a good idea is to consider putting most of the testing on the API level, and then create end-2-end tests just for happy paths.</p><h3>3. Automate, automate, automate</h3><p>This will not be a surprise: in agile software development, automation is the key to success. For an application that is developed in iterations and a new version is deployed to the end users every sprint, after each sprint the number of regression tests grows. Those tests need to be executed for each following sprint to verify and prove that the application is still working properly in areas that were not under development in the current sprint. This creates a situation in which regression testing becomes longer and longer from release to release.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*DTSvicZJrVgYB2C0J8mHug.png" /></figure><p>A similar situation arises when a developer works with existing code. If there is no easy way to test changes during the development process with unit tests, the only choice is regression testing after all code has been developed.</p><p>To cope with such situations, automated tests are needed. And all kinds of tests should be automated. We need to remember that a in well-structured testing suite, most of the testing is done on the unit level. We then have a slew of integration/module tests. Then we have a smaller, but still quite big set of tests at the API level. On top of this pyramid, there is a set of end-to-end tests that are executed through the user interface, testing all layers of the application. The more tests are automated the better. But remember not to repeat yourself. In the best case scenario, developers would use Test Driven Development and user-facing tests would be developed according to Behavior Driven Development scenarios (acceptance criteria).</p><h3>4. Put human intelligence to work</h3><p>All right, automation is key, but does that mean we don’t need manual testers anymore? Of course not. We still need manual testers, but they have to do more meaningful work. Instead of constantly executing the same test scenarios, testers in agile need to focus on less structured aspects of testing or those aspects that are not likely to be automated.</p><ul><li>The main area of focus for manual testers in agile should be exploratory testing. Exploratory testing helps to find new defects of the application by allowing testers to explore this application outside strict testing scenarios. With time-boxed and focused exploratory testing, testers can find some rare corner cases that otherwise would not be found.</li><li>Another aspect of intelligent testing in agile is usability testing. This is not a type of functional testing, but still a very important aspect of each application. There is in fact no other way to test usability than just make the assessment manually by a human, and incorporate human intelligence into the process. Usability testers should take a good look at and verify any aesthetics defects that may become apparent, e.g. at different screen resolutions .</li></ul><h3>5. Continuous improvement</h3><p>The last, but by no means least aspect of agile testing is continuous improvements. This is something that we always need to remember. While technically part of Scrum approach, this is present in all agile approaches — the [sprint] retrospective.<br>The role of the retrospective is to assess the process of software development as a whole. The assessment provides feedback information from the team about what went well and what was challenging to them. In cases of good practices, we know that we need to keep following those practices, and more closely.<br>However, in the case of something that was problematic in the process, we need to find ways to amend practices related to the encountered challenges. When a new approach has been discussed and agreed on, the whole product team should focus on making the transition to the new practice. While following the new way, the team observes how the new process works. During the next retrospective, the team makes another assessment. Rinse and repeat.<br>Continuous improvement is also implemented through the introduction of new and better technology that may loosen some existing limitations or enhance something that may have been working fine thus far, but will be pushed further going forward.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*UN-y6QMJjbuLfvPLlsjHBg.png" /></figure><h3>Summary</h3><p>Agile testing is the new normal. There is no coming back to the waterfall approach in development or in testing. And while the five aspects of agile testing presented above seem to me to be the most important ones, they don’t constitute a complete list of good practices.</p><p>Still, to implement agile development right and to deliver quality software on time in an agile environment, these five are crucial. They lay the foundation for smaller and more local enhancements in testing processes. They are also some of the hardest to implement, because many of them are related to people’s mindsets. And the tester’s mindset is an enabler for truly agile testing.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfb65c1da08a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/c-f-data-driven-innovators/how-to-develop-quality-software-in-agile-five-aspects-of-agile-testing-that-i-find-important-cfb65c1da08a">How to develop quality software in agile? Five important aspects of agile testing</a> was originally published in <a href="https://medium.com/c-f-data-driven-innovators">C&amp;F Data Driven Innovators</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[New technologies for test automation to watch in 2022]]></title>
            <link>https://medium.com/c-f-data-driven-innovators/new-technologies-for-test-automation-to-watch-in-2022-d64a1f19c64?source=rss-16061b447488------2</link>
            <guid isPermaLink="false">https://medium.com/p/d64a1f19c64</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[low-code]]></category>
            <dc:creator><![CDATA[Marcin Ludzia]]></dc:creator>
            <pubDate>Thu, 16 Dec 2021 12:55:05 GMT</pubDate>
            <atom:updated>2021-12-16T12:55:05.224Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*172x3p8eXCv5tKDRgE1eIw.png" /></figure><p><strong>It’s almost New Year. Traditionally, this is a great time to take a step back and look from a distance to see upcoming trends and changes. In this article, I would like to describe some test automation tools that are worth experimenting with in the coming year. Some are new, others have already been here for a while, but if you haven’t heard about them, you should give them a try.</strong></p><p>My review covers some low/no-code tools, programming libraries and packages that can be used by enterprises, as well as by smaller companies. Coding tools may seem to be overrepresented, but that is simply because it is easier to fit them out with new features.</p><p><strong>1.</strong> <strong>TOSCA</strong></p><p>One of the two<strong> </strong>off-the-shelf tools in this review, Tricentis Tosca is among fastest-growing enterprise-level tools on the market. It allows for functional testing on the UI and API levels. It also includes some advanced AI-based mechanisms, like visual testing and risk-based testing.</p><p>With TOSCA, a test automation engineer can create automated tests using best industry practices — including model-based testing. This approach separates the testing scripts from test data. A set of test data creates a set of different test cases that are tested with a single script.<br>TOSCA comes with an integrated test runner which allows parallel test execution. This is particularly important for larger applications, where end-to-end tests can take several hours. Parallelization makes it possible to shorten this time significantly.<br>Creating tests does not require any development skills. All options can be clicked through in the tool’s interface. Additionally, TOSCA makes it easy to find elements of tested applications with its built-in scanner.<br>On the other hand, in a dynamic real-world project, where applications are under constant development, test maintenance in TOSCA may be time consuming. This is mainly due to the way creating test scripts is implemented in TOSCA. Currently, you must rebuild the existing test almost entirely. Of course, testing data remains the same, but still the maintenance process takes quite a lot of time.</p><p>Another drawback of TOSCA is that it lacks clear support for testing on different environments of different versions of the same application, for example, in DEV there is version 1.2, but in the QA environment version 1.1 is still being tested. Also, TOSCA doesn’t handle dynamic test configurations well. Consider a situation where your application might be configured differently for different customers and you want to test these different configurations. In such a case you would be forced to create different tests for each configuration.</p><p><strong>2.</strong> <strong>Postman</strong></p><p>The remaining off-the-shelf tool in this review, Postman is one of the most popular tools for automation testing on the API level. While definitely not new on the market, it still is one of the top-of-mind tools when you think of functional API tests.</p><p>Postman has a pleasant and intuitive user interface, which makes it a very good choice for novice test automation engineers. The tester can easily create an API endpoint test with just a few clicks . Then such a test can be parametrized. The testing itself (asserting results) requires some coding, but at entry and mid-level at most. To make it even easier, Postman provides ready-to-use code snippets that can be easily adapted to your needs. For more advanced users, Postman provides robust support for JavaScript-based programming to make really powerful testing possible.<br>Equipped with a built-it test runner, Postman allows the tester to manually run the whole test suite and analyze results. But for more sophisticated uses, it has its own command-line test runner — Newman. Newman is also available as a node.js package, so you can develop your own collection runner/framework and reporter that integrates for example with test management tools.<br>Well-documented, Postman has great learning materials available online free of charge. What is also important for novice users, it has a great community, which can help with more difficult scenarios.</p><p>While Postman is really a great tool, there are a few drawbacks. Test traceability might be challenging, which is especially important in regulated environments, where among other formal requirements, test traceability is required to proof testing results. The other thing is use of the tool by power users and deep customization with custom reporters, scripting etc… While it is generally possible, if the amount of custom code is significant, it is probably a better idea to move entirely to code-based testing with, for example, RestAssured (Java) or axios (in the case of node.js).</p><p><strong>3.</strong> <strong>PlayWright</strong></p><p>One of the most exciting new automation libraries to observe in 2022, this library is similar to the Puppeteer library developed by Google. In fact, PlayWright is being developed by the same people and maintained by Microsoft. Recently, it has become a truly cross-browser automation library, and now supports Chrome, Edge (Chromium-based), Firefox and Safari.</p><p>What makes PlayWright special is that it uses a different browser communication protocol than Selenium does. Where the popular Selenium library communicates over WebDriver, PlayWright communicates over the DevTools protocol (a.k.a. Debugging Protocol). This is an entirely different architecture for automating the browser. The DevTools protocol has significant advantages over the WebDriver protocol. First, it is truly bi-directional. It also provides better control over the browser — everything that is available in DevTools is also available through the DevTools protocol. This allows for more advanced manipulation in modern web applications, especially when it comes to SPA — Single Page Applications developed in modern frameworks like Angular, React or Vue. PlayWright implements advanced synchronization techniques for better stability of tests; you can also easily run concurrent multi-user tests.<br>Apart from enabling cross-browser testing over the DevTools protocol (which is a great step forward from Puppeteer, which allows testing for Chromium-based browsers only — Chrome, Edge, Opera), it also emulates popular mobile devices for mobile testing. So, you can even test your JS-based mobile applications with just a few adjustments.</p><p>However, PlayWright is quite new to the environment, and working with it may be a bit challenging, as there is still limited support and finding code snippets on the web for certain situations might be difficult.</p><p><strong>4.</strong> <strong>Selenium 4.0</strong></p><p>Selenium is the golden standard for end-to-end test automation. For many, Selenium is synonymous with automated tests. Lately, we have finally got a new version of Selenium, currently 4.0, and this version brings significant changes compared to version 3.x.</p><p>The main improvement is that with Selenium you will be able to communicate with the browser over both WebDriver and DevTools protocols. Especially the latter makes Selenium more modern and more capable of handling testing of modern SPA applications. The DevTools protocol gives you more control over the web browser and enables the development of more conscious tests. You can now observe network activity from the test perspective, or do some performance testing. There are tons of interesting use cases for DevTools in testing, for example programmatic activation of options such as “onHover” for all elements on the page, to assert tooltips.<br>Another feature that was added to Selenium 4 is a function called Relative Locators. The new methods introduced in Selenium allow you to find a web element that is situated relative to another element, for example toLeftOf() or above() a known element. This makes the development of some cases (e.g. finding elements on the list) more streamlined and potentially less flaky compared to hardcoded locators.<br>With the new version of Selenium, Selenium Grid and Selenium IDE were also updated. The former enables parallel testing, and the latter gives you the ability to record and play tests. Such tests can be then exported to several programming languages, which (when used carefully) can help test development faster.</p><p>Among Selenium’s drawbacks we should mention the lack of auto-synchronization features to work with modern SPA applications. Using the DevTools protocol may help, but compared, for example, to PlayWright, there is still a lot to be developed manually.</p><p><strong>5.</strong> <strong>Cypress</strong></p><p>Cypress is getting some good press lately, and for a good reason: it approaches end-to-end testing in a unique way. When many tools today provide browser automation based on the WebDriver protocol (developed by the Selenium project), tests in Cypress are written in JavaScript and Cypress runner integrates with the browser. Tests are then run directly in the browser. This approach makes end-to-end testing more stable and robust.</p><p>Even though Cypress is a test library/package for node.js, it is very opinionated, which can streamline the whole test development process. There is no need to select the assertion library, test runner, and other libraries. Cypress comes with a whole package ready to use.<br>Tests are developed only in JavaScript. This may be perceived both as a positive and a negative. JavaScript is actually the only language that runs inside the web browser (I am abstracting away from Web Assembly for now), which makes it native for browser-based testing. Also, because front-end applications are developed with JavaScript/TypeScript, this makes test development more integrated with features development. Developers and test automation engineers can work in the same technology.</p><p>However, there are some actual drawbacks of Cypress you should know about. Probably the main one is that Cypress doesn’t provide a fully cross-browser testing environment. It supports several web browsers (mainly Chromium-based ones), but it doesn’t support Safari. Also, Cypress does not support multi-tab testing, which is particularly useful for testing multi-user scenarios, and it does not support mobile testing.</p><p><strong>6.</strong> <strong>Pact</strong></p><p>While Postman makes functional testing on the API level easy and streamlined, Pact provides a totally different approach to API testing. Instead of creating functional tests, Pact is focused on contract testing. Contracts between producer (most often — back-end application) and consumer (most often — front-end application) are shared structures and contents of messages exchanged between them. Pact makes it possible to run integration tests for different parts of an application in isolation. This way back-end can be tested without front-end and simultaneously front-end can be tested with back-end mocked by Pact. This approach to application testing can enable deep integration and involvement of dev teams and testing teams.</p><p>The drawback of this approach is that it might be difficult to introduce, because it requires a highly skilled team. Also, even though development might be simplified, the initial setup and configuration is a bit heavy.</p><p><strong>Summary</strong></p><p>The coming year is set to bring us not only development in well-known and established tools, but also some new tools entering the mainstream. As always, there is no such thing as the one best tool for all test automation jobs. You need to be aware of what project you are working on (what your business goals are) and what are other technical circumstances. Condsidering all this , make an informed decision to get tools best aligned with your needs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d64a1f19c64" width="1" height="1" alt=""><hr><p><a href="https://medium.com/c-f-data-driven-innovators/new-technologies-for-test-automation-to-watch-in-2022-d64a1f19c64">New technologies for test automation to watch in 2022</a> was originally published in <a href="https://medium.com/c-f-data-driven-innovators">C&amp;F Data Driven Innovators</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>