DEV Community: VRaptor Code

CYPRESS X ROBOT FRAMEWORK

VRaptor Code — Tue, 11 Feb 2025 15:05:47 +0000

Cypress and Robot Framework are two popular tools for test automation, and it's no surprise that they are among the most requested in job openings. But which one is the best for you to invest your study time in? Find out in this post.

Approach and Architecture

Cypress

It is a test automation tool focused exclusively on testing modern web applications. It operates directly in the browser, which allows for more precise control over the behavior of the application during tests.
Cypress's architecture is based on Node.js and runs in the same event loop as the browser (which is awesome), enabling synchronous and more predictable test execution.
It is known for its ability to provide end-to-end tests with a strong focus on realistically simulating user interactions.

Robot

It is a generic automation framework that supports not only web application testing but also API testing, desktop automation, mobile apps, web, and more.
It is based on a keyword-driven architecture, where tests are written using a simple and readable syntax that can be extended with custom or existing libraries.
It is highly modular and can be integrated with various tools and libraries, such as Selenium for web testing (I'm not sure if this is very good), Requests for API testing, and many others.

Language and Syntax

Cypress

It uses JavaScript (or TypeScript) to write tests. This means that tests are written in a full programming language, which provides great flexibility and power to handle complex logic.
Its syntax is quite expressive and allows for command chaining, making it easier to write concise and readable tests.
Example code:

cy.visit('https://some_login_and_password_generation_site_for_test.com')
cy.get('input[name="username"]').type('Cypress is awesome')
cy.get('input[name="password"]').type('super_secret_password')
cy.get('button[type="submit"]').click()

Robot

It uses a text-based syntax that is more declarative and less verbose than traditional programming. Tests are written in plain text files or in tabular format.
The keyword structure allows even non-programmers to write tests, as long as they understand the application's domain.
Example code:

*** Settings ***
Library    SeleniumLibrary

*** Test Cases ***
Login Test
    Open Browser    https://some_login_and_password_site_again.com    chrome
    Input Text      name=username          robot_is_awesome_too
    Input Text      name=password          password_that_will_never_be_guessed_1234567
    Click Button    type=submit

Integration and Extensibility

Cypress

It is highly integrated with the JavaScript ecosystem, making it easy to integrate with CI/CD tools, front-end frameworks (like React, Angular, Vue), and assertion libraries (like Chai).
It also has a rich set of plugins that can be used to extend its functionality, such as plugins for report generation, integration with monitoring tools, etc.
It has external libraries for integration with databases like PostgreSQL.

Robot

It is highly extensible and can be integrated with a wide variety of libraries and tools. It supports integration with Selenium for web testing, Requests for API testing, DatabaseLibrary for database testing, and many others.
Its modular structure allows users to create their own keyword libraries, making it extremely flexible for different testing scenarios.
In addition, it has native support for integration with CI/CD tools and detailed report generation.

Performance and Speed

Cypress

When it comes to web testing, it’s hard to beat Cypress. It is known for its speed and efficiency in testing web applications. Since it operates directly in the browser, it can execute tests faster and with less overhead compared to tools that rely on external drivers (like Selenium). I know this has been mentioned in another post on my LinkedIn, but hey, it's true XD.
However, it may be less efficient in scenarios where you need to test multiple browsers or in distributed environments, as it is primarily designed to run in Chrome. But it integrates excellently with Firefox, and there’s an experimental project for running Cypress in Safari. You didn't know that? Check it out here: https://docs.cypress.io/app/references/launching-browsers#WebKit-Experimental

Robot

It may be slower compared to Cypress, especially when used with Selenium, due to the additional overhead of the browser driver and communication between the framework and the browser.
However, it can be scaled for parallel and distributed execution, which can help mitigate performance issues in large test suites.

Reporting and Debugging

Cypress

It offers an exceptional debugging experience, with integrated browser tools that allow inspecting the application state at any point in the test. It also automatically captures screenshots and video recordings in case of failures.
The reports generated are detailed and can be integrated with CI/CD tools for continuous monitoring.

Robot

It generates detailed reports and logs by default, which are highly customizable. These reports are useful for post-execution analysis and sharing results with stakeholders.
Debugging can be more challenging, especially for less experienced users, due to the declarative nature of the syntax and the reliance on external libraries.

Use Cases and Suitability

Cypress

It is ideal for teams developing modern web applications and already familiar with the JavaScript ecosystem. It is particularly well-suited for end-to-end testing and scenarios where simulating user interactions is critical.

Robot

It is more suitable for teams that need a generic and flexible automation solution capable of handling a variety of test types (web, API, database, etc.). It is particularly useful in environments where collaboration between technical and non-technical team members is important.
It is less focused on end-to-end testing of modern web applications and may not offer the same smooth development experience as Cypress .

What do you think? Which one is the best in your opinion?

embed Leave your comment below if you work with either of them or if you want to learn.
👇

💻 5 Tips to Improve Performance Testing with K6 🚀

VRaptor Code — Mon, 27 Jan 2025 15:11:25 +0000

Application performance is crucial to ensuring a good user experience, and load testing plays a key role in this process. K6 is a powerful open-source tool for performance testing, and here are 5 tips to get the most out of it:

Plan Your Test Scenario Before Writing the Script
Before diving into coding, understand the main goals of the test:

What is the expected behavior of the application under load?
How many simultaneous users do you want to simulate? (If unsure, ask stakeholders, POs, agilists, etc.)
Which endpoints need to be tested?
A solid plan saves time and avoids rework.

Use Modular and Reusable Scripts
Organize your K6 scripts so they are easy to maintain and reuse. Use functions to group repetitive logic and store common configurations in separate files.

💡 Tip: Combine scripts with dynamic input data to simulate realistic scenarios.

Monitor Strategic Metrics
In K6, metrics like response time, requests per second, and error rate are fundamental. Add checks and thresholds to ensure results are measurable and meet expectations.

check(res, {
  'response time < 200ms': (r) => r.timings.duration < 200,
})

Integrate K6 into CI/CD Pipelines

Automate load testing by integrating K6 into your CI/CD pipeline. This helps identify performance bottlenecks before reaching production. Tools like GitHub Actions, Jenkins, or GitLab are great options for automation.

Analyze Results in Depth

After each test run, analyze the metrics and logs to identify issues. Use tools like Grafana, New Relic, Dynatrace, or others for real-time visualization and detailed reporting.

💡 Conclusion:

Testing your application's performance is an investment that can prevent future problems and increase customer satisfaction. With these tips, you can use K6 to create efficient tests and ensure a robust application.

For a ready-made template with pre-built scenarios, download the repository: https://github.com/DougSantos3/template_performance_testing_k6

And you, do you already use K6 in your projects? Share your experiences below! 👇

How does Cypress work?

VRaptor Code — Wed, 22 Jan 2025 19:02:49 +0000

It is a web and API end-to-end (E2E) testing automation tool that runs directly in the browser, which sets it apart from other testing tools. The way it works is key to its efficiency and popularity.

Runs within the same browser environment

When you run a test, it integrates directly into the browser where your application is loaded.

This means it has full access to:
DOM (HTML structure)
Network (HTTP/HTTPS requests)
Local storage and cookies
Browser events

💡 Think of Cypress as a co-pilot sitting inside the car (browser) with access to everything that's going on. It can see the dashboard (DOM), hear the commands (events), and even adjust the controls (like modifying cookies).

Executes tests in real-time

It doesn't use WebDriver (unlike tools like Selenium). It runs directly in the same event loop as the browser.
This allows tests to be fast, reliable, and synchronized
because:
There's no delay in communication between the test and the browser.
It knows exactly when elements are available or when requests have finished, without needing "manual waits."

💡 If you ask Selenium to check if a button is visible, it has to ask the browser and wait for a response. Cypress "looks with its own eyes" inside the browser and knows immediately.

Instant feedback

When a test fails, Cypress shows exactly:
What went wrong (e.g., element not found)
The state of the application at the time of the error (e.g., DOM, console, network)
You can even replay the steps manually in the visual interface to understand the problem.

Powerful and easy-to-use features

It makes writing tests much easier with:
Chained commands (cy.get().click())
Automatic waits (no need for sleep, it waits for elements to appear or requests to finish)
Event simulation like clicks, typing, and scrolling
API interception (mocking or validating requests)

Why is it so good?

Easy to set up

Just install with a single command (npm install cypress) and start writing tests, no complex configurations needed.
It runs directly in the browser, so there's no need to install additional drivers.

Fast and reliable

Since it runs in the same environment as the application, it avoids synchronization issues. Sometimes with Selenium, the test might fail not because it's poorly written or the application crashed, but because Selenium couldn't connect — this doesn't happen with Cypress.

Integrated features

UI and API testing in the same place
Automatic screenshot and video capture of tests
Integration with Allure reporting

What about you, have you already used Cypress in your projects or would you like to learn more about it? Comment here! 👇

Understanding the Android Studio menus for cleaning and rebuilding a project

VRaptor Code — Fri, 03 Jan 2025 21:49:42 +0000

Do you know when you're testing an Android app and it crashes, or when you want to build it, but various errors show up in Logcat (Android's log terminal), and you decide to clean up through Android Studio, but have no idea what's really going on? Well, in this article, we will explain in a very straightforward and quick way each type of clean-up and which one is best to use.

File → Invalidate Caches / Restart

Purpose Clears the Android Studio cache and restarts the IDE. This resolves indexing issues, phantom errors, or broken configurations.

What is indexing in the context of Android Studio?
In Android Studio, indexing is the process by which the IDE scans, analyzes, and organizes all the project files (source code, libraries, dependencies, resources, etc.) into an internal index. This index makes various essential Android Studio functionalities faster and more efficient, such as:

Autocomplete
Refactoring (renaming variables, classes, methods)
Quick navigation between files and symbols
Real-time error validation
Efficient project-wide search
Going back to Invalidate Caches: Clears the temporary files and caches of Android Studio.
Forces the IDE to reindex the project.

Resolves issues related to autocomplete or configurations that aren't being applied correctly.

When to use:

Autocomplete is not working.
The project has errors that don't appear in the source code.
After updating plugins or libraries."

Build → Clean Project

Purpose: Removes all files generated during the build process, such as compiled classes, temporary libraries, and previous APKs.

What it does:

Deletes files in the project's build/ folder.
Ensures there are no remnants from old builds.
When to use:
After significant changes in the code.
When there are build issues that might be related to old remnants.

Maven equivalent: mvn clean

Build → Rebuild Project

Purpose: Performs a Clean followed by a full rebuild of the project.

What it does:

Removes all files in the build/ folder.
Recompiles the entire project from scratch.
When to use:

After significant changes in the code or dependencies.
When the project is not compiling correctly.
Maven equivalent: mvn clean install

Code → Code Cleanup in Android Studio.

What is it? The option Code → Code Cleanup is used to automatically format and optimize source code in Android Studio. It applies predefined coding style rules, removes unnecessary imports, and makes other improvements to the code, making it cleaner and more standardized.

What does Code Cleanup do?

Removal of Unused Imports:

Deletes imports that are not being used in the file.

Code Formatting:

Adjusts indentation, spacing, and line breaks according to the style set in Android Studio.

Code Optimization:

Replaces redundant instructions with more efficient alternatives.
Simplifies complex expressions.

Warning Fixes:

Automatically resolves small warnings identified by the Android Studio Lint.

Style Standardization:

Applies rules defined in the style configuration file (Code Style Settings).

How to use Code Cleanup?

Go to Code → Code Cleanup.
Select the files you want to clean (it can be a file, a directory, or the entire project).
Choose a cleanup profile (default or custom).
Click Run.

Before Code Cleanup:

fun greet() { println("Hello, World!") }

The code is more organized, with proper indentation and spacing.

When to use Code Cleanup?

Before submitting code for review (code review).
After finishing a new feature.
To maintain consistency in coding style.
Now you know how to keep your code clean and beautiful in Android Studio!

Extras (Commands with Mvn)

mvn clean package

Purpose: Removes old compiled files (clean) and packages the project into a file (package, usually a JAR or APK in the case of Android).
When to use: After modifying the source code to ensure all changes are correctly applied to the final artifact.
mvn clean package Build → Clean Project: Removes old files and compiles.

mvn clean install

Purpose: Removes old files (clean), recompiles the project, and installs the resulting artifact (JAR or APK) into the local Maven repository. This ensures that dependencies and libraries are correctly available in the classpath. When to use: When adding or updating dependencies in the pom.xml file (or build.gradle in Android Studio). mvn clean install Build → Rebuild Project: Removes, compiles, and installs.

Summary:

File → Invalidate Caches: Clears cache and restarts Android Studio.
Build → Clean Project: Removes old compiled files.
Build → Rebuild Project: Cleans and recompiles the entire project.
Code → Code Cleanup: Formats, optimizes, and organizes the code.

That's all for today. I hope you enjoyed it. If so, I kindly ask you to comment on what you thought and don't forget to like.

[Resolved] Many places where we need to configure the JDK in IntelliJ

VRaptor Code — Wed, 27 Nov 2024 14:40:34 +0000

If you work with Java or Kotlin, you'll need to configure the JDK in IntelliJ. Below are the important points.
I use asdf, which is a version manager that allows you to install multiple languages. So let's go...

Local configuration per project

File -> project structure

You can download the JDK through IntelliJ or point to an installer on your machine.
Each project can use different versions of the JDK, so you can work on projects that require different JDKs.

Global configuration

The JDK will be available for all projects in IntelliJ.
When you create a new project, IntelliJ may ask for this JDK as the default.

Extras

Configure in Maven.

File -> Settings -> Build, Execution, Deployment -> Build Tools -> Maven

Configure in Gradle.

Well, that's it for today. Don't forget to leave a comment on what you think.