We live in a dynamic world of constantly changing trends and new emerging technologies. This sea of knowledge and constant growth might lead us to feel lost at times, and in need of some guidance, especially when it comes to our career.
We all want to stay up to date and ahead of the game, and when it comes to the test automation field – Things are no different. We strive to be the best testers or developers we can possibly be while processing the best set of test automation skills we can achieve.
To start the new decade with a bang 💥 – We’ve gathered 4 of your favorite test automation experts to share their top test automation trends for 2020, and help us drive our skills toolbox up to the next level. Rex Jones II, Joe Colantonio, Pooja Shah & Karthik KK. We also opened the stage for all of you out there to have the opportunity to become the 5th panelist 😲 by simply creating a post and sharing a testing trend. The trendiest trend we found was Corina Pip‘s trend that was published on her Twitter account, as seen below:
As promised, she became our 5th and honorable panelist that was selected to present in this live event✨
All of these great speakers discussed their trends and answered your burning questions 🔥:
- Selenium 4 and its upcoming new features by Rex Jones II (02:10-16:10 mins)
- Rise of C# .Net Core and how it’s changing the landscape of automated testing by Karthik KK (17:40-35:05 mins)
- Shifting to API and Integration testing from UI focused end-to-end testing by Pooja Shah (37:00-57:22 mins)
- Low code automation solutions by Joe Colantonio (58:05-1:04:15 mins)
- Clean code by Corina Pip (1:04:50-1:16:41 mins)
This was an event to remember – Feb 13th 2020! 🎉
Below is the full recording of the webinar ⏯:
Webinar Session Summaries
Below you will find all the session summaries you NEED to read and final tips from our wonderful gurus!
(Here you can also download the Webinar’s slides🤩):
- Rex Jones II – Selenium 4
- Karthik KK – Rise of C# .Net Core
- Pooja Shah – Shifting to API Testing
- Joe Colantonio – Low Code Automation Solutions
- Corina Pip – Clean Code
- Have more questions?
Rex Jones II – Selenium 4 and its New Features (Session Summary)
Selenium is a family of products (for automating web browsers) including the following: Selenium IDE (Record and playback tool), Selenium WebDriver (API allowing to create and execute test scripts) and Selenium Grid (Run tests across more than one browser, more than one operating system and more than one machine in parallel).
Selenium 4 is currently available in Alpha (pre-release early version), and includes various new features, such as:
- Selenium IDE
- Now available for Firefox and Chrome.
- Backup element selectors – Recording the tests with more than one locator, thus enabling for more test stability while changes are being made.
- Ability to add a plugin and export our code. Existed in the previous Selenium versions, but this Alpha release has fewer test frameworks.
- Selenium WebDriver
- Adopting the W3C protocol – Become a standard since 2018 and one of the major changes in Selenium 4.
- Relative locators – Enabling to find elements regarding the position of another element.
- Access to Chrome Debugging Protocol – Providing a direct communication line to Chrome browser, and for writing stable locators.
- Below is a diagram of the new Selenium 4 architecture from Rex’s webinar presentation:
- Selenium Grid
- New architecture for Selenium Grid, supporting 4 new processes: Router, Distributer, Session Map and Node (The previous architecture included: Hub and Node. The hub included 3 processes that are now separated in the new architecture into Router, Distributer & Session Map).
- Observability – Trace IDs helping us with debugging.
- Selenium Grid is more convenient for modern tech, like Docker (using it to scale the grid) and Kubernetes (to setup a grid machine).
- Selenium ChangeLog – Each change for the core languages fro Selenium:
- C#: https://github.com/SeleniumHQ/selenium/blob/master/dotnet/CHANGELOG
- Java: https://github.com/SeleniumHQ/selenium/blob/master/java/CHANGELOG
- Python: https://github.com/SeleniumHQ/selenium/blob/master/py/CHANGES
- Ruby: https://github.com/SeleniumHQ/selenium/blob/master/rb/CHANGES
👉✨Check out the full session by Rex Jones II from 02:10-16:10 mins, and jump to the live audience Q&A time from 12:18 mins!
Karthik KK – Rise of C# .Net Core (Session Summary)
There are many programming languages out there – But C# is undoubtedly the most interesting language in the market right now with .Net Core and its cross-platform support running the same code on Windows, MacOS and Linux operating systems – That’s its true power! 💪
- .Net Core is gaining traction among the developer community more than ever before following the introduction of Blazor technology.
- C# has great community support and Fortune 500 companies are using .NET as their tech stack for application development. According to TIOBE Index of programming language, we can see that although Java is still at the top, there is a distinct increase of the C# index, as seen below:
- Selenium 4 is adding more capabilities for C# language binding and almost all the features included in Java will be included in C# during its release.
- TestProject natively supports C# .Net Core as one the language bindings to write code and export recorded code from the platform.
👉✨Check out the full session by Karthik KK from 17:40-35:05 mins, and jump to the live audience Q&A time from 29:35 mins!
Pooja Shah – Shifting to API and Integration Testing (Session Summary)
Using a real-life example of testing a rocket 🚀 until launching it to make an analogy and explaining how API testing should look like. It is not end-to-end user flow testing, but rather testing what’s going in the “back”, inside the systems. Think as if all of our projects are like rocket launches, and differ what testing needs to be in API and what in UI.
Below is a demo from Pooja’s webinar presentation, showing how to test a flight site (search for Pune and Delhi and want to see if the rendered results match the source of destination), by UI testing vs. API testing:
- In the code, there are 2 files – One for UI and one for API. And you can see in the demo below the API test worked fast as lightning! ⚡ They are much more easier to write, execute and maintain.
- In UI testing there are scenarios where you might have too many combinations, potentially leading to regressions. So if we are only testing data – one should probably go with API testing. Whereas, if it includes also data representation and high-level checks – Then one should probably go with end-to-end tests.
- There’s increasing adaption to micro-services in product development, reminding us of the necessity of having more and more API testing – So that individual micro-services can be properly tested before released.
- API testing helps upskill while decreasing the gaps between testers, developers and DevOps, by knowing the “magic” behind the scenes of the product being tested.
- The actual ideal shift would be even towards unit testing and help our developers to write better unit tests, so we could write fewer API tests as well.
- End-to-end testing is good – But only when done wisely 😉
👉✨Check out the full session by Pooja Shah from 37:00-57:22 mins, and jump to the live audience Q&A time from 51:12 mins!
Joe Colantonio – Low Code Automation Solutions (Session Summary)
Joe used an example from a company he worked for, creating software for radiologists, and they had a concept called “Low Touch”. They wanted people to spend less time on the software, and more time looking at the X-Rays to see if they can detect cancer earlier. This is the same kind of approach seen going on with test automation tools – Going aways from code-centric approach, and going more towards having the tools help us to create code for us which we can modify. Basically, a “test first, code less” kind of approach.
In Joe’s TestGuild automation podcast, more and more are talking about tools acting as wrappers on top of Selenium and Appium (such as TestProject), that have all the functionality that you normally would have to write from scratch. You can now benefit from writing tests quicker without having to focus on the automation piece.
Many tools are also coming out with AI/ML type of technologies, helping to create a diagnose of if a test fails, why it fails, and help us create quicker tests so that we’re not focusing on the code as much as focusing on the testing.
TestProject, for instance, has a concept called Addons – Testers around the world can create functionality and then upload to a shared library. Then anyone can create an account for free and use these Addon building blocks to help you create automation.
It’s not that you will not need programming skills. You are going to need those skills, but mainly you should understand how things connect. If you look at any developers nowadays creating high-code, a lot of them are pulling libraries and just connecting them. We really need to focus on the testing with a background in programming, not necessarily focus on the programming first and then testing last.
👉✨Check out the full session by Joe Colantonio from 58:05-1:04:15 mins!
Corina Pip – Clean Code (Session Summary)
When talking about “clean code” we need to make sure that:
- Everything is in its place – Classes, tests, resources, etc. to easily find anything when needed.
- Proper naming – Naming test methods, classes, packages, we need to make sure to give them proper naming so that these names reflect what those particular items are doing.
- Separation of concerns – A test deals with a test, and every helper code that it needs will be somewhere else. All the test data processing that needs to be done will be done in its dedicated place. Tests should only focus on the testing part, and everything else should be taken from somewhere else.
- Reusing existing code – We should use existing code, instead of writing it all from scratch.
- Aim to write short tests as much as possible. Less code is better! If your tests are smaller – They are simpler. If you can do something in one line of code, it is much better than doing the same but with 100 lines of code (easier to maintain and easier to read) 🤗
- Make sure that your tests are predictable, having the same results while running on the same test environment.
Why is clean code important?
- Easy onboarding for other team members
- Easy maintenance and update
- Easy to find things
- Smoothly running tests and Easy configuration of test runs
How can we achieve a clean code?
- Spend time learning the programming language that we are using.
- Keep up with updates of programming language/framework
- Code reviews as a learning process
- Involve developers
- Refactor what does not work, early! The earlier you refactor your code – The less you will have to change later on.
👉✨Check out the full session by Corina Pip from 1:04:50-1:16:41 mins, and jump to the live audience Q&A time from 1:13:16 mins!
Have More Questions?
⁉ At the end of the webinar, all the gurus gathered for an open discussion, answering more Q&As from the audience and sharing their best tips and tricks (1:18:04-1:27:00 mins).
⁉ Many questions came up during the webinar. We invite you to continue the discussion in our forum and send out all the open questions you had, that we did not have time to answer:
Make sure you are up to date with the latest trends!🙌
✨See you at our next webinar✨