Development

CVE-2025-32896 – Apache SeaTunnel Unauthenticated Arbitrary File Read and Deserialization Vulnerability

CVE ID : CVE-2025-32896

Published : June 19, 2025, 11:15 a.m. | 1 hour, 29 minutes ago

Description : # Summary

Unauthorized users can perform Arbitrary File Read and Deserialization
attack by submit job using restful api-v1.

# Details
Unauthorized users can access `/hazelcast/rest/maps/submit-job` to submit
job.
An attacker can set extra params in mysql url to perform Arbitrary File
Read and Deserialization attack.

This issue affects Apache SeaTunnel:
Severity: 0.0 | NA

Visit the link for more details, such as CVSS details, affected products, timeline, and more…

CVE-2025-6019 – Libblockdev Polkit Local Privilege Escalation

CVE ID : CVE-2025-6019

Published : June 19, 2025, 12:15 p.m. | 29 minutes ago

Description : A Local Privilege Escalation (LPE) vulnerability was found in libblockdev. Generally, the “allow_active” setting in Polkit permits a physically present user to take certain actions based on the session type. Due to the way libblockdev interacts with the udisks daemon, an “allow_active” user on a system may be able escalate to full root privileges on the target host. Normally, udisks mounts user-provided filesystem images with security flags like nosuid and nodev to prevent privilege escalation. However, a local attacker can create a specially crafted XFS image containing a SUID-root shell, then trick udisks into resizing it. This mounts their malicious filesystem with root privileges, allowing them to execute their SUID-root shell and gain complete control of the system.

Severity: 7.0 | HIGH

Visit the link for more details, such as CVSS details, affected products, timeline, and more…

CVE-2025-6266 – FLIR AX8 Unrestricted File Upload Vulnerability

CVE ID : CVE-2025-6266

Published : June 19, 2025, 12:15 p.m. | 29 minutes ago

Description : A vulnerability was found in FLIR AX8 up to 1.46. It has been declared as critical. This vulnerability affects unknown code of the file /upload.php. The manipulation of the argument File leads to unrestricted upload. The attack can be initiated remotely. The exploit has been disclosed to the public and may be used. The vendor was contacted early about this disclosure but did not respond in any way.

Severity: 6.3 | MEDIUM

Visit the link for more details, such as CVSS details, affected products, timeline, and more…

CVE-2025-4738 – Yirmibes Software MY ERP SQL Injection

CVE ID : CVE-2025-4738

Published : June 19, 2025, 1:15 p.m. | 1 hour, 14 minutes ago

Description : Improper Neutralization of Special Elements used in an SQL Command (‘SQL Injection’) vulnerability in Yirmibes Software MY ERP allows SQL Injection.This issue affects MY ERP: before 1.170.

Severity: 9.8 | CRITICAL

Visit the link for more details, such as CVSS details, affected products, timeline, and more…

Development

AI and Machine Learning in Selenium Testing: Revolutionizing Test Automation

Automation testing has long been a cornerstone of efficient software development and quality assurance processes. Selenium, as a widely adopted automation testing tool, has empowered testers to perform web application testing effectively. However, with the integration of Artificial Intelligence (AI) and Machine Learning (ML), Selenium testing is undergoing a paradigm shift, enabling smarter, faster, and more accurate test automation.
This blog explores how AI and ML are transforming Selenium testing, their benefits, use cases, and the future of automation testing.

Understanding AI and Machine Learning in Testing

Artificial Intelligence (AI): The simulation of human intelligence in machines, enabling them to perform tasks like reasoning, learning, and problem-solving.

Machine Learning (ML): A subset of AI that allows systems to learn and improve from experience without explicit programming.

When applied to Selenium testing, AI and ML enable automated test scripts to adapt to changes, predict outcomes, and enhance decision-making processes.

Challenges in Traditional Selenium Testing
While Selenium is a powerful tool, traditional testing methods face several challenges:

Dynamic Web Elements: Modern web applications frequently use dynamic elements, making locators brittle and prone to failure.

High Maintenance: Frequent application updates require constant updates to test scripts.

Limited Test Coverage: Manually writing scripts for edge cases is time-intensive and error-prone.

Debugging Complex Scenarios: Debugging errors in lengthy test scripts can be tedious.

Data Handling: Handling large volumes of test data efficiently is often challenging.

AI and ML are designed to address these issues, making automation more intelligent and adaptive.

How AI and ML Enhance Selenium Testing
1. Self-Healing Tests
AI-powered frameworks can detect changes in the application’s UI and automatically update locators, reducing test failures caused by dynamic elements.

Example: AI identifies changes in button attributes (e.g., id, class) and adapts the XPath or CSS selectors dynamically.

Code Example:from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def self_healing_test(driver, locator_type, locator_value):
try:
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((locator_type, locator_value))
)
return element
except Exception as e:
print(“Locator needs adjustment”, e)
# AI adjustment logic can be implemented here
2. Predictive Analytics
ML algorithms analyze historical test data to predict potential failures or high-risk areas in the application.

Example: Identifying modules with higher bug recurrence rates for targeted testing.

3. Smart Test Case Prioritization
AI algorithms prioritize test cases based on factors like code changes, user behavior, and defect history.

Benefit: Focus on high-risk areas first, optimizing testing efforts.

Code Example:from sklearn.ensemble import RandomForestClassifier
import pandas as pd

# Sample dataset with test case details
data = pd.DataFrame({
‘test_case_id’: [1, 2, 3, 4],
‘recent_failures’: [3, 0, 1, 2],
‘execution_time’: [5, 2, 3, 4],
‘priority_score’: [0, 0, 0, 0]
})

# ML model to predict priority
model = RandomForestClassifier()
data[‘priority_score’] = model.predict(data[[‘recent_failures’, ‘execution_time’]])
data = data.sort_values(by=’priority_score’, ascending=False)
print(data)
4. Enhanced Test Coverage
AI generates additional test cases by analyzing user behavior, covering edge cases that may not have been considered.
5. Visual Regression Testing
AI compares screenshots of application versions to identify visual discrepancies, ensuring UI consistency.
Code Example:from PIL import ImageChops, Image

def compare_images(image1_path, image2_path):
img1 = Image.open(image1_path)
img2 = Image.open(image2_path)
diff = ImageChops.difference(img1, img2)
if diff.getbbox():
diff.show()
else:
print(“Images are identical”)
6. Natural Language Processing (NLP)
NLP-powered tools enable writing test cases in plain English, bridging the gap between technical and non-technical stakeholders.

Popular AI-Powered Tools for Selenium Testing

Testim

Features self-healing capabilities and AI-driven insights.

Simplifies test creation with a visual interface.

Applitools

Specializes in visual testing and visual AI.

Provides automated layout checks for responsive design.

Mabl

Combines Selenium with ML to create adaptive and reliable tests.

Focuses on continuous testing.

Functionize

AI-based automation testing tool with NLP capabilities.

Creates codeless tests from natural language instructions.

Sauce Labs

Offers AI-enhanced analytics for test performance and issue identification.

Use Cases of AI and ML in Selenium Testing
1. E-Commerce Testing

Automating cart workflows, payment gateways, and personalized recommendations.

Visual regression testing for product display consistency.

2. Healthcare Applications

Validating dynamic forms and user flows.

Ensuring compliance with regulatory standards like HIPAA.

3. Banking and Financial Systems

Testing multi-factor authentication workflows.

Predictive analytics for risk-based testing.

4. Social Media Platforms

Ensuring seamless user interaction across various browsers and devices.

Testing dynamic and personalized content feeds.

5. IoT and Smart Devices

Validating web interfaces controlling IoT devices.

Testing integrations with voice assistants using NLP.

Benefits of AI and ML in Selenium Testing

Reduced Maintenance Effort: Self-healing capabilities minimize the need for manual intervention in script updates.

Faster Test Execution: Intelligent prioritization and optimization save time.

Enhanced Accuracy: AI-driven locators and insights reduce false positives and negatives.

Broader Test Coverage: Generates edge cases and automates complex workflows.

Improved ROI: Faster releases with fewer bugs increase the return on investment in testing.

Future of AI and ML in Selenium Testing
The integration of AI and ML in Selenium is still evolving, but the possibilities are immense:

Fully Autonomous Testing: Test scripts that generate, execute, and adapt without human intervention.

Real-Time Learning: Systems that learn from live user data to improve test cases continuously.

Cross-Domain Applications: Expanded use cases in AR/VR, blockchain, and IoT testing.

Codeless Automation: More robust and intuitive tools for non-technical testers.

AI-Driven Reporting: Detailed insights into application health and testing efficiency.

Conclusion
AI and ML are revolutionizing Selenium testing, making it smarter, faster, and more reliable. By integrating AI-powered tools and frameworks, organizations can overcome traditional testing challenges, achieve higher accuracy, and accelerate software delivery cycles. As the technology evolves, the future of Selenium testing looks brighter than ever, with AI and ML leading the way.
Ready to embrace AI in your Selenium testing? Start exploring these innovations and transform your automation strategy today!

Keywords: Selenium, AI in testing, machine learning in Selenium, self-healing tests, automation testing, AI-powered tools for Selenium, intelligent test automation.

Development

Behavior-Driven Development (BDD) with Selenium and Cucumber

Behavior-Driven Development (BDD) is a methodology that bridges the gap between business and technical teams by emphasizing collaboration. It uses plain language to define application behavior, making it easier for non-technical stakeholders to contribute to the development process. Selenium and Cucumber are widely used together in BDD to automate web application testing.
This blog provides a detailed guide to implementing BDD using Selenium and Cucumber, including coding examples to help you get started.

What is BDD?
BDD focuses on the behavior of an application from the end user’s perspective. It uses scenarios written in Gherkin, a domain-specific language with a simple syntax:

Given: Precondition or context.

When: Action or event.

Then: Outcome or result.

Example:Feature: Login Functionality
Scenario: Valid user logs in successfully
Given the user is on the login page
When the user enters valid credentials
Then the user is redirected to the dashboard

Tools Used

Selenium: Automates web browsers to test web applications.

Cucumber: Enables writing tests in plain English (Gherkin syntax).

Java: Programming language for writing test automation scripts.

JUnit/TestNG: Test framework to execute Cucumber tests.

Setting Up Your Project

Create a Maven Project:

Add dependencies in pom.xml:<dependencies>
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-java</artifactId>
<version>7.11.0</version>
</dependency>
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-junit</artifactId>
<version>7.11.0</version>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>4.10.0</version>
</dependency>
</dependencies>

Directory Structure:

src/test/java: For step definitions.

src/test/resources: For feature files.

Writing a Feature File
Save this file as login.feature in src/test/resources/features:Feature: Login Functionality

Scenario: Valid user logs in successfully
Given the user is on the login page
When the user enters valid credentials
Then the user is redirected to the dashboard

Scenario: Invalid user cannot log in
Given the user is on the login page
When the user enters invalid credentials
Then an error message is displayed

Creating Step Definitions
Create a Java file LoginSteps.java in src/test/java/stepdefinitions:package stepdefinitions;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import io.cucumber.java.en.*;

public class LoginSteps {
WebDriver driver;

@Given(“the user is on the login page”)
public void userIsOnLoginPage() {
System.setProperty(“webdriver.chrome.driver”, “path_to_chromedriver”);
driver = new ChromeDriver();
driver.get(“https://example.com/login”);
}

@When(“the user enters valid credentials”)
public void userEntersValidCredentials() {
WebElement username = driver.findElement(By.id(“username”));
WebElement password = driver.findElement(By.id(“password”));
WebElement loginButton = driver.findElement(By.id(“login”));

username.sendKeys(“validUser”);
password.sendKeys(“validPassword”);
loginButton.click();
}

@Then(“the user is redirected to the dashboard”)
public void userIsRedirectedToDashboard() {
String expectedUrl = “https://example.com/dashboard”;
assert driver.getCurrentUrl().equals(expectedUrl);
driver.quit();
}

@When(“the user enters invalid credentials”)
public void userEntersInvalidCredentials() {
WebElement username = driver.findElement(By.id(“username”));
WebElement password = driver.findElement(By.id(“password”));
WebElement loginButton = driver.findElement(By.id(“login”));

username.sendKeys(“invalidUser”);
password.sendKeys(“invalidPassword”);
loginButton.click();
}

@Then(“an error message is displayed”)
public void errorMessageIsDisplayed() {
WebElement error = driver.findElement(By.id(“error”));
assert error.isDisplayed();
driver.quit();
}
}

Configuring the Runner Class
Create a Java file TestRunner.java in src/test/java/runners:package runners;

import org.junit.runner.RunWith;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;

@RunWith(Cucumber.class)
@CucumberOptions(
features = “src/test/resources/features”,
glue = “stepdefinitions”,
plugin = {“pretty”, “html:target/cucumber-reports”},
monochrome = true
)
public class TestRunner {
}

Running Your Tests

Open a terminal.

Navigate to your project directory.

Run the following command:mvn test
This will execute all scenarios defined in the login.feature file.

Best Practices for BDD with Selenium and Cucumber

Keep Scenarios Simple: Use concise and descriptive steps in Gherkin.

Reuse Step Definitions: Avoid duplicating code by reusing steps where possible.

Parameterize Steps: Handle multiple inputs by parameterizing your Gherkin steps.

Organize Files: Maintain a clear structure for features, steps, and configurations.

Continuous Integration: Integrate Cucumber tests with CI/CD pipelines for automated execution.

Conclusion
BDD with Selenium and Cucumber is a powerful combination for creating readable, maintainable, and effective test automation suites. By leveraging this approach, teams can foster collaboration, improve test coverage, and ensure high-quality software delivery. Start implementing BDD in your projects today and experience its benefits firsthand!

Keywords: BDD, Selenium, Cucumber, Automation Testing, Behavior-Driven Development, Gherkin, Step Definitions, Test Automation Framework.

Shift Left Testing Principles: Catch Bugs Early, Deliver Faster

If software projects still followed a “code everything first, test at the end” model, modern teams would be drowning in last-minute bugs, missed launch dates, and emergency hot-fixes. Customers have little patience for broken features, and competitors ship improvements weekly sometimes daily. To keep pace, engineering leaders have embraced Shift Left Testing: moving software testing
The post Shift Left Testing Principles: Catch Bugs Early, Deliver Faster appeared first on Codoid.

Development

Data-Driven Testing with Selenium WebDriver

 
Data-driven testing is a robust testing methodology that focuses on testing the functionality of an application using multiple sets of data. Instead of hardcoding input values and expected results, this approach separates test logic from the test data, enhancing reusability and maintainability. Selenium, being a popular automation tool, supports data-driven testing seamlessly when integrated with testing frameworks like TestNG or JUnit.
In this blog, we’ll delve into the concept of data-driven testing, explore its benefits, and demonstrate how to implement it using Selenium with detailed coding examples.

What is Data-Driven Testing?
Data-driven testing involves executing test scripts multiple times with different sets of input data. The test data is typically stored in external sources such as:

Excel files

CSV files

Databases

JSON or XML files

This approach is particularly useful for validating applications where the same functionality needs to be tested with various input combinations.

Benefits of Data-Driven Testing

Reusability: Test scripts are reusable for different data sets.

Maintainability: Test logic is separated from test data, making maintenance easier.

Scalability: Allows extensive test coverage with diverse data.

Efficiency: Reduces redundancy in writing test scripts.

Tools Required

Selenium WebDriver: For browser automation.

Apache POI: To read/write data from Excel files.

TestNG/JUnit: For test execution and data provider functionality.

Setting Up Your Project
Add Dependencies
Include the following dependencies in your pom.xml if you’re using Maven:<dependencies>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>4.10.0</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>5.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>5.2.3</version>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.8.0</version>
</dependency>
</dependencies>

Code Example: Data-Driven Testing Using Excel and TestNG
Step 1: Create the Test Data
Create an Excel file named TestData.xlsx with the following columns:

Username
Password

user1
pass1

user2
pass2

Save this file in the project directory.
Step 2: Utility Class to Read Excel Data
Create a utility class ExcelUtils.java:import java.io.FileInputStream;
import java.io.IOException;
import org.apache.poi.ss.usermodel.*;

public class ExcelUtils {
private static Workbook workbook;
private static Sheet sheet;

public static void loadExcel(String filePath) throws IOException {
FileInputStream fis = new FileInputStream(filePath);
workbook = WorkbookFactory.create(fis);
}

public static String getCellData(int row, int column) {
sheet = workbook.getSheetAt(0);
Row rowData = sheet.getRow(row);
Cell cell = rowData.getCell(column);
return cell.toString();
}

public static int getRowCount() {
return sheet.getLastRowNum();
}
}
Step 3: Test Class with Data Provider
Create a test class LoginTest.java:import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.*;

public class LoginTest {

WebDriver driver;

@BeforeClass
public void setup() {
System.setProperty(“webdriver.chrome.driver”, “path_to_chromedriver”);
driver = new ChromeDriver();
driver.get(“https://example.com/login”);
}

@DataProvider(name = “loginData”)
public Object[][] loginData() throws Exception {
ExcelUtils.loadExcel(“TestData.xlsx”);
int rowCount = ExcelUtils.getRowCount();
Object[][] data = new Object[rowCount][2];

for (int i = 1; i <= rowCount; i++) {
data[i – 1][0] = ExcelUtils.getCellData(i, 0);
data[i – 1][1] = ExcelUtils.getCellData(i, 1);
}
return data;
}

@Test(dataProvider = “loginData”)
public void testLogin(String username, String password) {
WebElement usernameField = driver.findElement(By.id(“username”));
WebElement passwordField = driver.findElement(By.id(“password”));
WebElement loginButton = driver.findElement(By.id(“login”));

usernameField.sendKeys(username);
passwordField.sendKeys(password);
loginButton.click();

// Add assertions here to verify login success or failure
}

@AfterClass
public void teardown() {
driver.quit();
}
}

Best Practices for Data-Driven Testing

Use External Data: Store test data in external files to reduce script changes.

Parameterize Test Cases: Avoid hardcoding data in test scripts.

Error Handling: Implement robust error handling for file operations.

Optimize Performance: Load test data only once if possible.

Clear Test Data: Ensure the test environment is reset before each run.

Advantages of Data-Driven Testing with Selenium

Flexibility: Easily test multiple scenarios by changing input data.

Enhanced Coverage: Test edge cases by providing varied data sets.

Reduced Redundancy: Write fewer scripts for multiple test cases.

Conclusion
Data-driven testing is a vital strategy for efficient and thorough test automation. By combining Selenium with tools like Apache POI and TestNG, you can create scalable and maintainable test suites that cover a wide range of scenarios. Implement this approach to enhance your testing process and ensure high-quality software delivery.

Keywords: Data-Driven Testing, Selenium, TestNG, Apache POI, Automation Testing, Excel Integration, Test Automation Framework.