oscarbarrios.tech

openSUSE 2025 talk

Tue, 10 Jun 2025 12:00:00 +0000

Hello everyone!

The openSUSE Conference 2025 will happen very soon, and although I’m going to participate remotely this year from the coast of Cambrils, I’m incredibly happy to have been able to contribute with my pre-recorded talk: “Quality on Autopilot: Scaling Testing in Uyuni”.

It’s a fantastic opportunity to share the journey we’ve undertaken at SUSE to scale quality in an open-source project as dynamic and complex as Uyuni. The question I tried to answer is: How do you scale quality in a fast-moving open-source project?

What is the Talk About? A Recap of Our Journey

For those who can’t attend, the talk is a tour through our adoption of TestOps practices to bring more automation, visibility, and resilience into our Quality Engineering processes. This wasn’t an overnight change, but a story of small, iterative improvements.

Here are the pillars of our strategy that I discussed in the presentation:

🏗️ Solid Foundations with IaC: We started by automating our infrastructure with Terraform and Salt. This gave us the ability to create consistent, on-demand test environments, eliminating the classic “it works on my machine” problem.
📊 Visibility with Observability: We integrated Prometheus and Grafana to monitor our test trends. This allows us to analyze historical data to detect regressions, identify flaky tests, and understand the behavior of our tests over time.
🏷️ Managing Flaky Tests and Known Issues: We created a custom system that connects our QE workflow in GitHub directly with our test reports. Using a script, we automatically tag Cucumber scenarios, providing immediate visibility into the status of a failed test (if it’s flaky, if a bug has already been reported, etc.).
⚡ Accelerating Feedback with Smart Test Selection: For Pull Requests, we implemented smart test selection based on code coverage. This allows us to run only the relevant end-to-end tests for the affected components, drastically reducing CI times.
🩺 Continuous Synthetic Monitoring: We introduced “Fitness Functions” into our daily pipelines. These are key product metrics (like bootstrap or synchronization times) that give us a continuous view of the system’s overall health and provide early warnings about product-level issues.
💻 Improving the Developer Experience: We designed our own DevContainers to standardize the development environment in IDEs. This has greatly simplified the onboarding process and aligned the entire team.
🤝 Transparency with the Community: We are working on making our AWS test reports public. We believe transparency is key in open-source to build trust and accountability.

More Updates Coming Soon!

This post is just the beginning. In the coming days, I plan to write a bit more detail on some of these topics and, most importantly, share a summary of what I’ve learned from other incredible talks that I’ll be able to follow at the openSUSE Conference 2025.

Also, as soon as the organizers upload the videos to YouTube, I will embed the full recording of my talk right here for you to watch.

My presentation

Mentoring for GSoC 2025. AI-Driven Test Selection

Tue, 10 Jun 2025 12:00:00 +0000

Hello everyone,

I’m thrilled to announce that I’ll be participating as a mentor for the openSUSE Project in this year’s Google Summer of Code 2025! It’s always a privilege to work with talented contributors and help guide innovative projects within our open-source community.

This year, I’ll be mentoring an exciting large-scale project titled: “AI-Driven Test Selection in Uyuni’s Pull Request Acceptance Tests”.

I’m also very happy to introduce our contributor, Ahmed Khaled (Akayiz), who will be leading the charge on this project.

The Challenge: Slow Feedback in Pull Request Testing

To ensure code quality in Uyuni, we run an extensive suite of acceptance tests for every new pull request. While this is crucial for preventing breakages from reaching our master branch, the process has its challenges. Currently, these tests execute most of the suite, leading to an average runtime of about one hour. This long wait delays valuable feedback for our developers and also increases our infrastructure costs.

The Project: Building a Smarter, Faster Testing Strategy

Our goal with this GSoC project is to tackle this challenge head-on by developing a machine learning model.

Inspired by Facebook’s “Predictive Test Selection” paper, the model will be trained on historical data, including past pull requests, test results, and code coverage data. Its purpose is to predict the smallest possible subset of tests that are most likely to fail for any new pull request.

By running only this highly relevant, smaller set of tests, we aim to:

Dramatically speed up feedback for developers.
Reduce infrastructure costs.
Maintain our high standard of test coverage.

The project will involve a fantastic mix of technologies, including Python for machine learning, Ruby and Cucumber from our test suite, and GitHub Actions and the GitHub API for integration.

The Journey Ahead

The project is now active, and we’re looking forward to the journey ahead, with the midterm evaluation coming up in August and the final submission in late October. I’m incredibly excited to see what Ahmed will build and the positive impact it will have on Uyuni’s developer productivity.

Stay tuned for more updates as we progress!

FailTale

Tue, 10 Jun 2025 12:00:00 +0000

Hello everyone,

I’m incredibly thrilled to share some exciting progress on a Proof of Concept I’ve been working on, called FailTale! 🐛 🔍

For anyone interested in the intersection of AI and test automation, you can check out the project directly on GitHub: FailTale on GitHub

The Challenge: Making Debugging Less of a Chore

We’ve all been there—a test fails in a complex CI pipeline, and the long, tedious process of debugging begins. Sifting through logs, trying to reproduce the issue, and identifying the root cause can be a significant drain on time and energy. The core idea behind FailTale is to streamline this process and get to the bottom of issues faster by leveraging the power of AI.

How FailTale Works

When a test fails, FailTale intelligently collects relevant context to build a complete picture of the failure. This includes:

Test steps being executed
The error stack trace
Logs and outputs from custom console commands
Screenshots of the state at the time of failure

Once this data is collected, it leverages Large Language Models (LLMs) to analyze everything and offer insights and hints about the potential root cause.

Early Success and What’s Next

I’ve already integrated FailTale in its first attempts into our Uyuni CI pipeline, and it’s incredibly motivating to see that it’s already starting to provide some genuinely interesting root cause hints for our test failures.

The work doesn’t stop here, of course. Here’s what I’m focused on now and what the future holds:

Enriching Context with a RAG System: I’m currently working on a Retrieval-Augmented Generation (RAG) system. The goal is to process the extensive Uyuni documentation to further enrich the context provided to the AI, which should lead to even more accurate insights. It’s a bit more complex, which also makes it a bit more fun!
Future Architecture (Decoupling): Looking ahead, I’m considering decoupling the execution of commands (which connect to components via SSH) into a new, dedicated MCP Server. This would make the architecture even more robust and modular.

Join the Journey!

I’m really excited about where this project could go and hope to share a more detailed demo or perhaps even a talk about it later this year as it evolves.

For anyone working with test automation, especially within a Cucumber Test Framework, I’d love for you to take a look at the project on GitHub. Feedback, ideas, contributions, or even just a star would be fantastic. Let’s make debugging less of a chore, together!

SeleniumConf 2025 Experience

Mon, 31 Mar 2025 12:00:00 +0000

Attending SeleniumConf 2025 was an incredible experience for me. I arrived on Wednesday around noon, and in the evening, we had a speakers’ dinner. The food was excellent, and I had the opportunity to start meeting some really interesting people.

Thursday marked the official start of the conference. The breakfast at the Hotel Las Arenas was amazing, and upon arriving at the venue, there was even more breakfast and coffee available. I was quite nervous, unsure if my talk would go well.

As soon as I arrived, the first thing I did was check if everything was working properly with my laptop, ensuring I could present smoothly while viewing my speaker notes. Everything was set up correctly, allowing me to relax and start enjoying the talks.

The first session was a keynote explaining that Selenium and Appium are aiming to collaborate on their respective projects as much as possible. This is why the conference was held jointly for both technologies.

The first talk I attended was The Ultimate Swiss Army Knife of UI Software Testing, Accelerating Workflow-Based Automation. It was a bit difficult to follow since the room was too bright, making it hard to see the code on the screen. The session focused on an implementation to test graphical interfaces.

Next, I attended TestOps: A Journey to Story-Based Releases The presenter set the bar incredibly high with an amazing presentation and visually engaging slides. The talk followed the journey of a team transitioning from merging everything into a single branch to working with multiple development, testing, and staging environments. This approach, based on microservices, highlighted the challenges of integrating different implementations occurring simultaneously.

After this, it was time for my talk: Speed Up PR Tests with Smart Code Coverage-Based Selection It went quite well—I was able to explain the design and showcase the code we implemented for Smart Test Selection. There were many questions, and even after the Q&A session, people approached me throughout the two days to discuss implementations and share ideas.

One key question was how to measure the effectiveness of recommended tests essentially, whether the suggested tests were truly the best ones. This is something we should investigate further to develop relevant metrics. Another idea was whether this approach could be applied to unit tests, though given their fast execution time, I am not sure it would be necessary.

A Mozilla engineer introduced me to BugBug, an AI-powered tool that selects the best tests for bug coverage based on bug reports. Additionally, I learned about Cluecumber, a project by Trivago for visualizing test reports, which seems worth exploring.

After lunch, I attended João Proenza’s talk, Decoding Synthetic Monitoring: A Journey from E2E UI Tests to Service-Level Probes This was particularly interesting because it aligns with something we have already started implementing. I call it “Fitness Metrics,” but they refer to it as “Synthetic Monitoring.” The concept involves deriving a metric from end-to-end tests to observe system performance trends. João’s example focused on API calls generated from user actions within the application, decoupling the UI layer and focusing on backend validation.

Later, I partially attended Lauro Moura’s session, Advancing WebDriver BiDi support in WebKit , which explained the benefits of BiDi, a technology that modern testing frameworks are increasingly adopting.

Another engaging talk was Beyond Logs: Achieving Observability with Selenium and Grafana by Giannis Papadakis. It covered test observability using a Prometheus Push Gateway to monitor test results in Grafana and send alerts via email or Slack. The talk also introduced Loki for better test log management, reinforcing my plan to explore Loki further. During the Q&A, I shared insights about our Jenkins-Exporter as an alternative approach to processing test reports for Grafana.

The first day’s closing keynote was delivered by Angie Jones, focusing on AI and MCPs. She demonstrated an MCP executing Selenium commands and shared various AI-driven automation techniques. It was amusing when she mentioned my talk, but to give an example of how AI can help to enhance the test selection.

On the second day, the opening keynote was delivered by my former colleague, Almudena Vivanco, a Performance Engineer at Lidl. She emphasized the importance of performance testing as a team-wide responsibility rather than just a task for a specialized group of engineers.

The first session I attended was Flakiness in Your Tests Isn’t Down to the Test Framework by David Burns, which provided strategies for better managing waits in test automation.

Next, I attended Reviving Windows App Automation: NovaWindows Driver for Appium 2 by Teodor Nikolov. He introduced a new Appium driver for Windows, which primarily relies on command-line executions but also integrates UI automation at times. His demonstration showed that this new implementation significantly improves test execution speed. Hopefully, it gains more contributions and visibility.

After enjoying a fantastic paella for lunch, I attended Unleash Synthetic Monitoring with Supercharged Test Automations by Leandro Meléndez, also known as Señor Performo. This talk reiterated concepts similar to our Fitness Metrics, confirming that we are on the right track with our implementation.

Following this, I had the chance to record a short podcast episode with Leandro, where we discussed my professional journey and my talk. He was a great host.

The last session I attended was the Lightning Talks, but nothing particularly stood out.

In summary, I left the conference highly motivated about test observability, although AI seemed to be the main theme of the event.

Information:

My presentation

Test Frameworks Workshop

Mon, 25 Oct 2021 18:40:26 +0000

The slides contains a list of Test frameworks, organized by these categories:

Unit Testing
Mock Testing
API Testing
GUI Testing
BDD Testing
End-to-End Testing

Also, it propose a playground to test a website using CucumberJVM + Selenium.

Code Coverage Workshop

Thu, 30 Sep 2021 08:40:26 +0000

These slides contain a basic workshop to understand the tools offered by IntelliJ to check the code coverage and cyclomatic complexity.

The course code is available from here https://github.com/srbarrios/codecoverage-workshop

JUnit 5 Workshop

Thu, 30 Sep 2021 08:40:26 +0000

These slides contain a basic workshop to understand the features offered by the JUnit5 Test Framework to develop unit tests.

The course code is available from here https://github.com/srbarrios/junit5-tutorial

Software bugs

Mon, 30 Aug 2021 18:30:36 +0000

This year I am going to give classes on software testing at the Autonomous University of Barcelona, one of the new lessons that I would like to include in this course is the concept of Defect or Bug, since it is a term that we talk about daily in any work of the sector.

In these slides I want to share the most basic concepts to understand what a bug is and to be able to work in a development team.

I hope it is useful for you!

How to develop End to End tests for Uyuni

Mon, 21 Dec 2020 20:07:00 +0000

Having new joiners in our QA Squad, I decided to record a video that explains how to set up a local sandbox for Uyuni and how to configure a RubyMine or IntelliJ IDE to develop and debug our Cucumber End to End tests.

In order to deploy our test environment, we use Sumaform, which is a tool that make use of Terraform and Salt to deploy our Virtual Machines in local. By the way, it also supports deployment in AWS. To debug our tests, we use ChromeDriver poping up a browser where we can follow all the actions made by our test framework, thanks to the breakpoints in our IDE.

Smart integration tests

Sun, 20 Dec 2020 10:00:56 +0000

When you start automating testing for a new project, everything is very simple. When you have several years and hundreds of tests to launch, things get complicated.

It is important to have a good organization of the tests, a good prioritization of them and, when possible, use some technique that allows to intelligently select which tests best cover the changes made in the product code.

In this presentation I explain a bit the changes that I led in my project to speed up our tests.

The main contribution made in my project has been to introduce a new Jenkins pipeline to validate a Pull Request before merging it. This pipeline runs the acceptance tests, so we can better cover a end to end usage. Also it includes the build process uisng Open Build Service, where we build only those packages changed by the Pull Request speeding up this process. In addition, you can manually select the functional areas that you want to test. Our next steps on that goal, it will be filter the resources we need to deploy through Terraform depending on the functional areas to be tested and finally integrate this with our GitHub repository.

From Quality Control to Quality Engineering

Thu, 12 Nov 2020 10:00:56 +0000

As I explained in a previous post, my team at SUSE uses BDD methodology, adapted to our needs.

I would like to introduce the different models of Quality, each of them complementing the other. From Quality Control where it focuses in defect detection, through Quality Assurance that works on defect prevention to Quality Engineering that make more focus in tools and processes to facilitate the whole team to build a product with quality in all the stages of the development, from design to delivery.

I think this is a very interesting talk for the teams, including the QA team itself, as some teams still have the idea that a QA Engineer is in charge of testing the product so that it is delivered without defects, but it is a lot more than that!

SUSECon 2020 Talk: Automated QA for Maintenance Updates

Sun, 20 Sep 2020 19:07:00 +0000

Hello from SUSECon Digital 2020!

This has been an amazing conference, and I was thrilled to have the opportunity to present my session, “Automated QA Maintenance Updates in SUSE Manager”. For anyone who couldn’t make it, I wanted to share the story of how we tackled a major challenge for our team: the long and tedious process of validating maintenance updates.

The journey began by confronting a significant bottleneck. In the past, our team spent an average of two weeks and 3-4 QA Engineers to perform a single manual validation for our monthly maintenance updates. It felt like Groundhog Day; the steps were always the same, methodical but highly repetitive.

Our key strategic shift was to stop treating maintenance QA as a separate phase and instead automate it. We achieved this by defining the QAM workflow and then applying our existing technologies to it. During the talk, I demonstrated how we now have a fast and unassisted deployment using Terraform for provisioning virtual machines and Salt for configuration.

On top of that, we use Jenkins Pipelines to orchestrate the entire workflow as code. This pipeline runs a suite of Cucumber tests in parallel, which are written in natural language to reproduce customer steps. These automated tests perform complex actions like synchronizing products, bootstrapping clients, running various client tests, and more.

One of the best outcomes of this automation is a much happier and more efficient team. We reduced the validation time to just one or two days, allowing us to focus on more complex cases and contribute more to the development cycle. Furthermore, the architecture is scalable and can be adapted by other projects facing similar challenges. Our tech stack for this solution includes Jenkins, Terraform, Salt (as part of Sumaform), and a testing framework based on Ruby, Capybara, Cucumber, and parallel_tests.

Watch the Full Talk Here!

The official recording of the session is available, and I’ve embedded it below so you can watch the full presentation and see all the details.

DevOps Introduction

Sun, 05 Jul 2020 16:00:56 +0000

Within SUSE I have launched a new initiative, energizing a new monthly meetup dedicated to DevOps topics.

To break the ice, I did the first presentation. I can’t show you the recording but I leave you the presentation, I hope you like it! :)

Starter skeleton of a Cucumber Test Framework

Mon, 18 May 2020 09:07:00 +0000

During the lockdown, here in Spain, I deciced to to start a skeleton of a Cucumber Test Framework, so I can use it in future projects. It is based in the TechStack we are currently using in the Uyuni project, where I contribute.

This is a Cucumber project skeleton written in Ruby, using Capybara framework to interact with a website. It also include CI powered by GitHub Actions.

Starter skeleton of a Java Backend

Mon, 18 May 2020 09:07:00 +0000

This is a Java backend example, with easy API endpoints that can connect to a Redis NoSQL Database. Also, this backend has the bases to be deployed in Google Cloud.

SUSE Quiz

Tue, 10 Mar 2020 09:07:00 +0000

This hackweek project is an Unity3D app, available in Android, IOS and HTML5 platforms.

The idea is to welcome new joiners inviting them to play this game. The game will have questions about SUSE, the new joiners will need to ask other SUSE employees for the correct answer, socializing and learning SUSE culture at the same time. When they win the game an e-mail will be sent to a concrete e-mail address (it might be someone from facilities) and they will receive a small gift as Welcome Pack. For instance, they could receive the small chameleon or a t-shirt.

Jenkins Pipeline & Parallel Cucumber

Sat, 06 Jul 2019 09:07:00 +0000

During a hack week, I put in place a Jenkins Pipeline which has different stages, for our testsuite project, so in case a stage fails further stages will be skipped. In addition, as the testsuite is written using Cucumber in Ruby, I make a profit of parallel_tests framework and gain almost 50% of total execution time.

I presented an informal demo to my team, I hope it can be useful to have an idea of Jenkins Pipelines.

BDD in a development team

Wed, 27 Feb 2019 15:27:56 +0000

Today I would like to give you an overview about how we automated tests in my project and to explain a bit what Cucumber Framework is. Writing these slides, I realised that we can’t explain Cucumber without first have some context about the reasons to create that framework.

So first of all, you’ll see a bit of theory about Behavior-Driver development process, then I’m going to introduce you to the Gherkin syntax and Cucumber framework.

New slides:

SUSE Manager slides:

Home Hosting

Tue, 30 Oct 2018 19:38:44 +0000

When I started this blog, designed in WordPress, my first thought was to start on my machine and when I would had been the design ready, then buy a domain to publish it. In the middle of that process, I was so excited about the project that I wanted to show it to my friends, in both platforms on my phone and their laptops. And I thought … why not deploy a hosting at home?

Is that possible? Can I do it with any cost? Ow yes! You can build a home hosting absolutely free! The first thing you need to know is what kind of Internet connection you have hired, that it going to tell you how you can connect with other users. In my case the ISP assigns me a Dynamic IP , that would be my “identification number”, so other users can connect with me using this IP. BUT, my IP is dynamic, that means it will change often, so you can not pass the IP to any friend to connect your machine :/

If your provider uses CG-NAT ask them if you can switch to Dynamic IP, in my case they changed it for free 🙂 But… What I really want is share with my friends a domain name like oubiti.com! Not an ugly IP like this 123.45.26.118!

Well, for that they invented Dynamic DNS. A DNS is a telephone directory but storing IPs, where you look for a domain name and you receive an IP. A dynamic DNS gives you the ability to change your IP as often as you want, which in our case it going to be the router whenever you receive a new IP from our ISP, whom will update that information on our Dynamic DNS service.

There are many companies that offer this free service, in my case I used https://www.noip.com/ , you can create an account easily, type the domain you want and create a free account, obtaining a Dynamic DNS.

Once created, we must setup the router to be responsible for sending the new IP Dynamic DNS, every time it changes. To do this, follow the steps in the wizard to set up your router .

See an example of my config:

AH! An important step! Doesn’t matter if you use a Dynamic DNS or just the IP, but if you want that your public IP redirects the traffic of a web page to your web server, you will need to do a “Port Forwarding” , see here an example using port 8080 and 80.

So far so good! You just need to make sure you have your web server running, you can try http: // localhost and if that works properly, wait a few minutes for DNS information to propagate and you can connect to your machine using the domain name you’ve chosen.

As last step, I had an issue, a kind of loop in the name resolution. If something goes wrong when you try to see your website using the new domain name (in my case “oubiti.ddns.net”), try to add that line to your local name resolution file.

Mac & Linux: /etc/hosts
Windows: C:\Windows\System32\drivers\etc\hosts

In another post, I will explain how to set up a web server with WordPress and MySQL database, using Docker containers!

MiPintura.com

Thu, 25 Oct 2018 13:10:55 +0000

Are you looking for an original painting? Do you need to frame yours?

We recommend MiPintura.com are experts in the sector!

Tailored paintings

Our passion is art and decoration

You can order any of the works exhibited in our catalog, as well as request any change of color or size in them. All our works are entirely hand painted by ourselves! No cheating or cardboard! there is nothing printed and retouched, they are painted from a blank canvas. They are delivered assembled in their frame, since they can not be rolled due to the thickness and texture of the paint. If you wish, we will include photos of the process.

DecoSnapp

Thu, 25 Oct 2018 12:57:37 +0000

You ‘re thinking of redecorating your living room , you’ve seen a beautiful painting and you love to take home? But… you don’t get the idea of how it will looks in the room?
DecoSnapp will show you it at home , through your mobile phone!

This app is designed to help everyone that needs to decorate a space, and wants to compare some possibilities before buy a new painting or poster.
Is developed with the aim to be a powerful tool for decoration and painting companies.

HurryMind!

Thu, 25 Oct 2018 11:46:43 +0000

Mental skill game, where you will have to solve word games and mathematical operations before the time runs out!

It’s my first game prototype using Unity 3D, it’s developed to be reusable or extended. You can checkout the project from here , if you have a GitLab account.

Also please give a try, downloading it for those platforms:

Android: iOS: