Forem: Melia Log

I left Windows for Ubuntu. Here’s everything I configured and what I learned

Melia Log — Fri, 09 Jan 2026 22:29:29 +0000

I left Windows for Ubuntu. Here’s everything I configured and what I learned

I recently decided to leave Windows and switch to Ubuntu for my development environment.

Not because Windows is bad, but because I wanted:

more control
a cleaner dev workflow
and to really understand what’s happening under the hood

This article is not a tutorial from someone who knows everything.

It’s a real dev journey: things I discovered while doing, tools I didn’t even know existed before, and why Ubuntu honestly surprised me (in a good way).

What I configured after installing Ubuntu

Installing and configuring Git

First thing first: Git.

Install Git

sudo apt install git

Configure global variables

git config --global user.name "your_name"
git config --global user.email "your_email"

# Check configuration
git config --global --list

At this point, Git is ready.

Java setup with SDKMAN (my first discovery)

Before Ubuntu, I had no idea that something like SDKMAN existed.

What SDKMAN allows you to do :

Install multiple JDK versions (8, 11, 17, 21…)
Switch versions globally or per project
Choose different distributions (Temurin, Zulu, Oracle, GraalVM…)

Install SDKMAN

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

Check installation

sdk version

List available Java versions

sdk list java

Install Java 21 (example)

sdk install java 21.0.9-tem

Switch Java version

For current session :

sdk use java 21.0.9-tem

Set as default :

sdk default java 21.0.9-tem

Verify :

java -version
#Or
javac -version

Mind blow moment :

I didn't know switching Java versions could be this clean and simple.

Node.js with NVM (another discovery)

Same story here.
I here about NVM before... but never really used it properly.

What is NVM?

NVM = Node Version Manager

It allows you to :

Install multiple Node.js versions
Switch between them per project
Avoid breaking old projects

Why it matters (real case)

Angular 20 ->requires Node ≥ 20
Older projects ->Node 18 or 16

Without NVM:

uninstall / reinstall Node
risk breaking projects

With NVM :

nvm use 18
#or
nvm use 20

No conflict
No sudo
No system break

Install NVM

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Close and reopen terminal, then :

nvm --version

Install Node 20

nvm install 20
nvm use 20
nvm alias default 20

Verify :

node -v
npm -v

PostgreSQL server + client

Install PostgreSQL

sudo apt update
sudo apt install postgresql-18 postgresql-client-18 postgresql-contrib

Check service

sudo systemctl status postgresql

Change postgres password

sudo -u postgres psql

Inside PostgreSQL:

ALTER USER postgres WITH PASSWORD 'your_new_password';

PgAdmin 4

Installed directly via Ubuntu App Center.
Simple. Clean. No headache.

Postman via Snap

sudo snap install postman

Launch:

postman

SSH Keys (BIG learning moment)

Before Ubuntu, I used to clone repos using HTTPS URLs.

Then I tried to clone my own repository, and GitHub asked for authorization.

That’s when I discovered SSH keys.

Create SSH key

ssh-keygen -t ed25519 -C "your_github_email"

Start SSH agent and add key

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Copy public key

cat ~/.ssh/id_ed25519.pub

Add key to GitHub

GitHub -> Settings
SSH and GPG keys
New SSH key
Paste key
Save

Test connection

ssh -T git@github.com

If you see:

Hi username! You've successfully authenticated...

SSH works.

Now I clone repositories without any access issues.

IDEs and account sync

IntelliJ IDEA -> App Center
VS Code -> App Center
GitHub account sync -> plugins, settings, themes restored automatically.

Final thoughts

What really surprised me is how simple everything feels on Ubuntu.

With:

a few commands
clear tools
no weird installers

Things that used to take a lot of time on Windows were done in minutes.

And most importantly:

I understood what I was installing.

This transition didn’t just change my OS
it changed how I see my dev environment.

My Docker Adventure: A Journey to Containerization

Melia Log — Thu, 12 Jun 2025 14:04:43 +0000

My Docker Adventure: A Journey to Containerization

Yesterday I said to myself, "What if I stopped using traditional software? What if I stopped installing XAMPP every time I started a new project? What if I used Docker instead?"

So there, no intense thinking - straight to Google "How to install properly Docker?" and off I went on my Docker adventure!

I installed WSL 2 on my Windows and off I went! But there was more to come. I said to myself, "What if I stop using MySQL and use Postgres?" Yes, I know, a lot of "what ifs" in a short space of time!

I had always used MySQL by default because it’s what tools like XAMPP and many tutorials use. But I started wondering: what’s the real difference between MySQL and PostgreSQL? They’re both relational database systems, they both use SQL... So why do some developers swear by Postgres?

I was especially curious because I saw Postgres used in a lot of modern full-stack tutorials, especially with Spring Boot or Node.js. Plus, I had read that it handled things like UUIDs more natively — and I like the idea of having those unique, unguessable IDs for security and scalability.

So I did a bit of digging, and here’s what I discovered:

Why PostgreSQL and not MySQL?

Better handling of complex data types: PostgreSQL supports types like JSON, XML, UUIDs, arrays, and even custom data types. Super useful when you need more flexibility in how you store data.
Closer compliance with SQL standards: PostgreSQL is known for sticking closely to SQL standards, making it more reliable for complex queries or scalable projects.
Extensibility: You can easily add functions, operators, or extensions in Postgres. It’s built to be modular and customizable.
Native UUID support: Unlike MySQL, which often requires workarounds or plugins, PostgreSQL has built-in support for UUIDs—perfect for generating secure, unique identifiers.
Great performance with large datasets: Benchmarks often show that PostgreSQL performs really well, especially when dealing with lots of relational data or complex operations.

I said to myself "Okay, let's go!"

Create Image

docker run --name container_name -e POSTGRES_PASSWORD=mypassword -p 5432:5432 -d postgres

Next, the big question: how do I connect my Spring Boot API with this image? I asked ChatGPT (my virtual mentor of the moment), who advised me to create an application.yml file.

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/postgres
    username: postgres
    password: mypassword
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

And then, panic! Error message: "Connection failed". My heart skips a beat! I go back to ChatGPT to find out what's wrong. He kindly explains that the problem lies in the application.properties file, which is selected by default.

Being the cautious beginner that I am, I was afraid of breaking everything by deleting it. As a compromise solution, I renamed it to system.properties.

And now the YAML file looked like this:

spring:
  application:
    name: project_name
  datasource:
    url: jdbc:postgresql://localhost:5432/database_name
    username: postgres
    password: my_password
    driver-class-name: org.postgresql.Driver

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.PostgreSQLDialect

  jpa.properties.hibernate.format_sql: true

I run the application again and get another error message: database not found

Alright, I realize I need to create the database first. After checking some YouTube tutorials, I'm ready to try these commands:

# Connect to postgres
docker exec -it (name or container_id) psql -U postgres
# Create database
CREATE DATABASE my_database;
# List existing databases
\l

I check the database and see it was created successfully, so I restart the run.

And then... BOOM! It works! My thirty-two teeth are so visible that I'm smiling (yes, even the wisdom teeth). What do you expect? I'm alone, with no mentor, just a dev trying to learn with an AI, YouTube and Google as my companions.

Table check

The run works, no errors, but are my tables created? How do I check? After some research, here are the magic commands:

docker exec -it container_id psql -U postgres -d database_name
\dt

At 1 a.m., seeing my tables well created, I finally decide to go to sleep. But my dev brain can't help but think: "Tomorrow, I'm trying to figure out Dockerfile, because all this manual image creation, it could be automated!"

Resources That Helped Me Along the Way

📺 This YouTube video that clearly explained how to install and use Docker on Windows.
📄 Microsoft's official documentation on installing WSL 2 — essential for getting Docker Desktop to work smoothly on Windows.

To be continued in my next Docker adventures...

Relationships in JPA: Creating Entities Without Dependency

Melia Log — Mon, 11 Nov 2024 12:40:18 +0000

Relationships in JPA: Creating Entities Without Dependency

When creating a backend API, it's common to work with entity relationships to organize data. Typically, in courses or tutorials, we mostly see bidirectional relationships. But what if you want one entity to exist independently of the other? In this article, we’ll explore how to use a unidirectional relationship with JPA/Hibernate to achieve this.

Context and Problem
Entity Modeling
Scenarios for Saving Data
- Creating a Student without a ThesisSchedule
- Updating the Student to Associate with a ThesisSchedule
Advantages of Managing the Relationship on Student's Side
Alternative: Managing the Relationship on the ThesisSchedule Side
Choosing the Right Configuration for Your Needs

Context and Problem:

Imagine you have two entities: Student and ThesisSchedule. The relationship between Student and ThesisSchedule is "many-to-one," meaning that a student can be associated with a thesis schedule, and each schedule can include multiple students.

In this case, our goal is to allow the creation of a Student without requiring a ThesisSchedule to be defined first. This independence is helpful, for instance, when adding students to the database before creating thesis schedules.

Problem encountered: With a bidirectional or poorly configured relationship, creating a Student may fail if a ThesisSchedule hasn’t been created yet, even with the annotation nullable = true. Let’s see how to solve this with a unidirectional relationship.

Entity Modeling

We’ll create Student and ThesisSchedule classes using a unidirectional "many-to-one" relationship from Student to ThesisSchedule.

Student entity code:

ThesisShedule entity code:

Here, we have a unidirectional relationship from Student to ThesisSchedule, indicated by the @ManyToOne annotation in the Student class. By specifying nullable = true, we allow a Student to be created without necessarily being associated with a ThesisSchedule.

Scenarios for Saving Data

Let’s see how this setup translates to the database and how data can be saved through an API.

Creating a Student without a ThesisSchedule

With this setup, we can create a student without providing a ThesisSchedule.

POST request to create a Student (without ThesisSchedule):

This creates a new entry in the Student table with a null value for the thesis_schedule_id column.

Result:

Updating the Student to Associate with a ThesisSchedule

Once a ThesisSchedule is created, we can update the Student record to associate with it.

Creating a ThesisSchedule:

This newly created ThesisSchedule might have an ID of 1.

Updating the student with ThesisSchedule:

Result:

Now, Larose is associated with the newly created ThesisSchedule.

Advantages of Managing the Relationship on Student's side:

Creation Flexibility: We can create a Student independently of a ThesisSchedule, allowing for independent entity creation.
Simplicity of Structure: A unidirectional relationship simplifies interactions, as ThesisSchedule doesn’t need to be aware of the relationship with Student.
Scalability: If we later need to make this relationship bidirectional, we can update the ThesisSchedule class to include a collection of Student.

Alternative: Managing the Relationship on the ThesisSchedule Side

In some cases, it may be more appropriate to manage the relationship from the ThesisSchedule side. This approach is useful if we want the thesis schedule to manage its associated students, keeping track of those participating in a specific schedule.

Entity Modeling

In this setup, ThesisSchedule holds a collection of Student to represent a "one-to-many" relationship, while Student doesn’t maintain a reference to ThesisSchedule.

ThesisSchedule entity code:

Student entity code:

In this configuration, ThesisSchedule contains a list of Student through the @OneToMany annotation. Consequently, students can be added or removed from ThesisSchedule without requiring a direct link in Student.

Advantages of Managing the Relationship on ThesisSchedule’s Side:

Data Centralization: All information about students associated with a thesis schedule is centralized in ThesisSchedule, making it easier to access relevant data.
Increased Control: ThesisSchedule can manage its students, simplifying the handling of groups of students participating in the same schedule.

Choosing the Right Configuration for Your Needs:

In conclusion, whether to manage the relationship on the Student or ThesisSchedule side depends on your application's specific needs:

Relationship Managed by Student: Use this setup if you want to create students independently of a thesis schedule and optionally link a schedule to a student later.
Relationship Managed by ThesisSchedule: This option is preferable if the thesis schedule should manage its students, making it the core of the relationship between entities.

Both configurations provide flexibility and allow for well-organized backend APIs based on the desired data relationships. By applying best practices to structure entity relationships, you can effectively model your database to meet your application’s specific needs.

Unidirectional relationships are a powerful option for managing optional dependencies between entities in a backend API.

I hope this solution helps other developers better understand and use unidirectional relationships in JPA/Hibernate.

Write Good Commit Messages

Melia Log — Wed, 16 Oct 2024 17:06:19 +0000

Write Good Commit Messages!

Introduction: Why Commit Messages Matter

Commit messages are often overlooked by developers, but they play a crucial role in collaborative project management. A good commit message helps your team—and your future self—understand the changes made without having to read every line of code. Unfortunately, many beginner developers (just like me by the way 😁) make the mistake of using vague messages like "fix" or "done," which makes the Git history impossible to follow.

The Problem with Bad Commit Messages

Here are some common examples of bad commit messages:

"fix"
"done"
"update"
"test"

These messages don’t explain what actually changed in the code. When you have dozens of commits like these in your history, it becomes very difficult to track the project's evolution. It also makes it harder for your team if they need to backtrack to a specific bug or change.

Why is this a Problem?

Vague commit messages present several issues:

Lack of clarity: They provide no information about what was changed.
Unusable Git history: When you want to roll back or review the project’s progress, you’re lost in a sea of meaningless messages.
Harder collaboration: Your teammates also don’t know what you did, making collaboration more difficult.

The Solution: Use "Badges" to Structure Your Commits

To make your commit messages clearer, use "badges" or specific keywords at the beginning of the message. This helps quickly identify the nature of the change. Here are a few examples:

[fix] for bug fixes
[feat] for new features
[docs] for documentation updates
[style] for style or formatting changes
[refactor] for code reorganizations without feature changes

Real-Life Examples of Good Commit Messages

To illustrate the difference between a bad and a good commit message, here are a few examples:

Bad: "fix"
Good: [fix] Fixed login page bug
Bad: "update"
Good: [feat] Added share button to articles page

These examples clearly show the difference. The first example doesn’t tell much about what was fixed, while the second explicitly explains which bug was fixed. Similarly, for adding a feature, the good message explains exactly what was added.

Bonus: Tips for Writing Clear Commits

Here are some best practices for writing effective commit messages:

Be clear and concise: Your message should describe exactly what you did without being too long.
Use the imperative form: Write your commit messages as commands. Example: "Add search functionality" instead of "Adding search functionality."
Ask yourself this question: "What does this commit change in the project?" If your message answers this clearly, you're on the right track.

Recap

Good commit messages help:

Keep a clean and understandable Git history.
Improve team collaboration.
Make project maintenance easier in the long run.

Conclusion

Now that you know how to structure your commit messages, it's time to put these tips into practice! Start writing clear and meaningful commit messages today. And if you've seen funny or confusing commit messages, share them in the comments!

Don’t forget to share this article with other developers and follow for more development tips!

Explication de SeleniumWebDriver : Automatisez votre Flux de Tests Web

Melia Log — Wed, 10 Jul 2024 15:53:18 +0000

Salut à tous,

Aujourd'hui, je vais vous parler de Selenium WebDriver, une nouvelle notion que je viens d'apprendre. Dans cet article, nous nous concentrerons principalement sur la théorie afin de comprendre ce qu'est Selenium WebDriver, son utilité et bien d'autres concepts associés.

Table des matières

Qu'est ce que Selenium?
Composants de Selenium
- Selenium IDE
- Selenium RC
- Selenium WebDriver
- Selenium Grid
Avantages et limites de Selenium WebDriver
Architecture du Framework Selenium WebDriver
Processus d'exécution d'un test
Comment utiliser Selenium WebDriver avec Java ?

Qu'est ce que Selenium ?

Selenium est un ensemble open-source d'outils et de bibliothèques qui permet d'effectuer des tests multi-navigateurs pour vérifier si le site web fonctionne de manière cohérente sur différents navigateurs Il est largement utilisé pour les tests automatisés des applications Web.

Compatibilité :

Selenium est compatible avec les langages C#, Java, Python, JavaScript, Ruby, Python et PHP.

Remarque :

Les testeurs sont libres de choisir le langage dans lequel concevoir les cas de test, ce qui rend Selenium très avantageux.
Il n'est pas obligatoire d'écrire le code Selenium dans le même langage que l'application. Par exemple, pour une application écrite en PHP, le script du test peut être écrit en Java.

Composants de Selenium

La suite des tests Selenium comprend quatre composants principaux:

Selenium IDE:

Selenium IDE pour Integrated Development Environement, est un outil d'enregistrement/d'exécution pour les tests fonctionnels (functionnal testing)

NB : Vous n'avez pas besoin d'apprendre un langage de script pour créer le test fonctionnel.

Selenium RC:

Selenium RC, pour Remote Controller nécessite des connaissances dans au moins un langage de programmation. Ses bibliothèques principaux sont :

Serveur
Client

NB : Architecture complexe et ayant des limites.

Selenium WebDriver

C'est un Framework permettant d'exécuter des tests multi-navigateurs et c'est une version améliorée du Selenium RC.

NB :

Bien qu'il soit une version améliorée de Selenium RC, son architecture est complément différente.
Il faut tout même connaitre un langage de programmation pour l'utiliser.

Selenium Grid

Pour l'exécution simultanée de cas de test sur différents navigateurs, machines et système d'exploitation.

NB :

Facilite les tests de compatibilités entre navigateurs.
Deux versions : Grid 1 (ancienne version) et Grid 2 ( nouvelle version).

Avantages et limites de Selenium WebDriver

Avantages de Selenium WebDriver

Support Multinavigateur :
Selenium WebDriver supporte de nombreux navigateurs tels que Chrome, Firefox, Safari, Edge, etc. Cela permet de tester les applications web sur différents environnements de navigation.
Contrôle Direct du Navigateur :
WebDriver interagit directement avec le navigateur, ce qui assure une meilleure précision et fiabilité des tests par rapport à d'autres outils qui utilisent des scripts injectés.
Support Multi-langage :
Selenium WebDriver permet d'écrire des scripts de test dans plusieurs langages de programmation tels que Java, Python, C#, Ruby, JavaScript, etc., offrant une grande flexibilité aux développeurs.
API Flexible et Puissante :
L'API de Selenium WebDriver est riche et permet de réaliser des tests complexes incluant des interactions avancées avec les éléments web, la gestion des cookies, des sessions, etc.
Open Source et Gratuit :
Selenium est un outil open source, ce qui signifie qu'il est gratuit et que la communauté contribue constamment à son amélioration et à son évolution.
Compatibilité avec Divers Outils de Test :
Selenium WebDriver peut être intégré avec des frameworks de tests populaires comme TestNG, JUnit, NUnit, ainsi qu'avec des outils de CI/CD comme Jenkins, Maven, etc.
Tests Répartis et Parallèles :
Avec Selenium Grid, il est possible d'exécuter des tests en parallèle sur plusieurs machines et navigateurs, ce qui réduit le temps total d'exécution des tests.
Offre une compatibilité avec IphoneDriver, HtmlUnitDriver et AndroidDriver

Limites de Selenium WebDriver

Limitation aux Tests Web :
Selenium WebDriver ne peut être utilisé que pour tester des applications web. Il ne supporte pas les applications desktop ou les applications mobiles natives.
Gestion des Pop-ups et des Fenêtres :
Selenium peut rencontrer des difficultés à gérer certaines pop-ups et fenêtres modales, surtout celles générées par le système d'exploitation.
Dépendance aux Sélecteurs de Page :
Les scripts de Selenium dépendent fortement de la structure et des sélecteurs des pages web (ID, nom, classes, etc.). Si l'interface utilisateur change fréquemment, les scripts de test doivent être constamment mis à jour.
Absence de Support pour Capturer les Erreurs Visuelles :
Selenium WebDriver ne peut pas détecter les erreurs visuelles telles que les problèmes d'alignement ou les couleurs incorrectes. Des outils supplémentaires comme Applitools Eyes peuvent être nécessaires pour les tests visuels.
Courbe d'Apprentissage :
Bien que Selenium soit puissant, il peut être complexe à maîtriser pour les débutants en raison de la nécessité de comprendre la programmation, l'automatisation des tests et l'API de Selenium.
Performance :
Les tests Selenium peuvent être plus lents que ceux exécutés par certains outils d'automatisation headless (sans interface utilisateur), surtout lorsque des captures d'écran ou des vidéos des tests sont nécessaires.
Maintenance des Tests :
En raison de la nature dynamique des applications web modernes, les tests Selenium nécessitent une maintenance régulière pour s'assurer qu'ils restent fonctionnels face aux changements de l'application.

Architecture du Framework Selenium WebDriver

L'architecture Webdriver est composée de quatre composants principaux :

Client Librairies (Bibliothèques Clients)
Les bibliothèques clientes sont des API fournies par Selenium pour différents langages de programmation. Les principales bibliothèques clientes sont disponibles pour :
- Java
- C#
- Python
- Ruby
- JavaScript (Node.js)
JSON Wire Protocol over HTTP (Protocole JSON Wire)
Le JSON Wire Protocol est un protocole standardisé utilisé par Selenium WebDriver pour envoyer des commandes aux navigateurs. Ce protocole définit une API RESTful qui permet de communiquer avec les navigateurs en utilisant des requêtes HTTP. Les bibliothèques clientes envoient des requêtes HTTP contenant les commandes Selenium aux serveurs WebDriver via ce protocole.
Browser Drivers (Drivers de Navigateur)
Chaque navigateur a son propre driver qui agit comme un pont entre Selenium WebDriver et le navigateur. Les drivers de navigateur reçoivent les commandes en JSON Wire Protocol des bibliothèques clientes et les traduisent en actions spécifiques au navigateur.
Les drivers de navigateur comprennent :
- ChromeDriver pour Google Chrome
- GeckoDriver pour Mozilla Firefox
- IEDriverpour Internet Explorer
- EdgeDriver pour Microsoft Edge
- SafariDriver pour Safari
Browsers (Navigateurs)
Les navigateurs sont les applications web réelles avec lesquelles Selenium interagit. Les drivers de navigateur lancent et contrôlent les instances des navigateurs pour exécuter les scripts de test. Les navigateurs peuvent être exécutés en mode graphique ou headless (sans interface utilisateur) pour des tests plus rapides.

Processus d'exécution d'un test

Écriture du Script : Le testeur écrit des scripts de test en utilisant les bibliothèques clientes de Selenium dans le langage de programmation choisi.
Envoi de Commandes : Les bibliothèques clientes envoient des commandes en utilisant le JSON Wire Protocol via des requêtes HTTP au driver de navigateur correspondant.
Interprétation des Commandes : Le driver de navigateur interprète les commandes et les traduit en actions spécifiques au navigateur.
Exécution des Actions : Le navigateur exécute les actions (comme cliquer sur un bouton, entrer du texte, etc.) et retourne les résultats via le driver de navigateur.
Retour des Résultats : Les résultats des actions sont renvoyés via le driver de navigateur aux bibliothèques clientes, qui les traitent et génèrent des rapports de test.

Comment utiliser Selenium WebDriver avec Java?

Pour cette section de pratique, je vous invite a lire cette article Introduction pratique aux tests d'applications Web avec Selenium WebDriver et Java.

Practical Introduction to Web Application Testing with Selenium WebDriver and Java.

Melia Log — Wed, 10 Jul 2024 15:46:02 +0000

A Practical Introduction to Web Application Testing with Selenium WebDriver and Java.

Hello everyone,

Today, I want to share with you a practical introduction to testing web applications with Selenium WebDriver. We'll look at how to write a simple test script in Java, using two mini-projects I recently completed.

Setting Up the Environment

Before we start writing our test script, we need to prepare our development environment. Here’s what we need:

Java JDK: Ensure that you have the Java Development Kit (JDK) installed.
IntelliJ IDEA: We'll use IntelliJ IDEA as our IDE.
Selenium WebDriver: We'll add the necessary libraries to the project.
Google Chrome: We will use the Google Chrome browser.
ChromeDriver: You’ll need to download the ChromeDriver that matches your version of Google Chrome.

Installing Selenium WebDriver

Step 1: Download Selenium WebDriver for Java.

Go to the official Selenium WebDriver site by clicking this link https://www.selenium.dev/downloads/.
Scroll down to the section Selenium Clients and WebDriver Language Bindings and download the Selenium WebDriver Java client. The download will be a ZIP file containing the libraries and the Selenium Java drivers.
Visit https://sites.google.com/chromium.org/driver/downloads to find out which version of ChromeDriver to download based on your Google Chrome version.
- How to check your Google Chrome version: In the URL bar of your Google Chrome browser, type: chrome://version.
Create a new Java project with Maven in IntelliJ IDEA. In this case, we'll call it SeleniumTestLogiciels.

Step 2: Add Selenium Libraries to the Project.

Extract the downloaded ZIP file to a folder on your computer.
In IntelliJ IDEA, click on File > Project Structure.
In the Project Structure window, click on Libraries.
In the Libraries window, click the + icon on the right for (New Project Library) and then choose Java.
In the Select Library Files window, navigate to the folder where you extracted Selenium WebDriver and select all the files inside it.
- Quick selection tip: Click the first item in the folder, hold down the shift key, and then, without releasing the key, use the mouse to go to the bottom of the list and click on the last item. Voila! :).
Click Apply and then Close.

Verify the Installation

Let’s create a simple test script to verify that Selenium WebDriver has been installed correctly.

Create a new class named NewsletterSignUpTest.
In the newly created class file, write a simple Selenium WebDriver test. Here’s an example script that opens one of my frontend projects in a web browser.

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class NewsletterSignUpTest {

    public static void main(String[] args) throws InterruptedException {
        // Setup WebDriver
        System.setProperty("webdriver.chrome.driver","C:\\Selenium WebDriver Chrome\\chromedriver-win64\\chromedriver.exe");
        WebDriver driver = new ChromeDriver();

        // Navigate to the page
        driver.get("https://time-tracking-dashboard-challenge-sooty.vercel.app/");

        // Maximize the browser window
        driver.manage().window().fullscreen();


        // Wait for 4 seconds before closing the browser
        Thread.sleep(6000);

        //close the browser
        driver.quit();
    }
}

Note: In the script above, replace C:\\Selenium WebDriver Chrome\\chromedriver-win64\\chromedriver.exe with the path to the ChromeDriver executable on your machine.

Run the test script.
- Note: If everything is set up correctly, this script should open a webpage in the Chrome browser and then close it.

Writing the Test Script for the `NewsletterSignUp` website

GitHub Repository Link: NewsletterSignUp_Repository

Below is the code for the NewsletterSignUpTest class we created earlier:


import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

import java.util.logging.Level;
import java.util.logging.Logger;

public class NewsletterSignUpTest {

    public static void main(String[] args){
        // Initialize logger for logging test results
        final Logger LOGGER = Logger.getLogger(NewsletterSignUpTest.class.getName());

        // Setup WebDriver
        System.setProperty("webdriver.chrome.driver","C:\\Selenium WebDriver Chrome\\chromedriver-win64\\chromedriver.exe");
        WebDriver driver = new ChromeDriver();

        try {
            // Navigate to the page
            driver.get("https://newsletter-sign-up-with-success-message-challenge-tau.vercel.app/");

            // Maximize the browser window
            driver.manage().window().fullscreen();

            // Wait for 5 seconds to observe the initial state
            Thread.sleep(5000);

            // Find the email input field and submit button
            WebElement emailInput = driver.findElement(By.id("email"));
            WebElement submitButton = driver.findElement(By.id("btnSubmit"));

            // Test invalid email submission
            emailInput.sendKeys("invalid-email");
            submitButton.click();

            // Wait for 4 seconds to observe the error message
            Thread.sleep(4000);

            // Verify the error message is displayed
            WebElement errorEmailMessage = driver.findElement(By.id("error-email"));
            String errorMessage = errorEmailMessage.getText();
            if ("Email is not in a valid format".equals(errorMessage)) {
                LOGGER.info("Invalid email test passed!");
            } else {
                LOGGER.severe("Invalid email test failed! Error message: " + errorMessage);
            }

            // Test valid email submission
            emailInput.clear();
            emailInput.sendKeys("validemail@example.com");
            submitButton.click();

            // Wait for 4 seconds to observe the success message
            Thread.sleep(4000);

            // Verify the success message is displayed
            WebElement successMessage = driver.findElement(By.id("card-success-message"));
            if (successMessage.isDisplayed()) {
                LOGGER.info("Valid email test passed!");
            } else {
                LOGGER.severe("Valid email test failed!");
            }


            // Verify the success email is correct
            WebElement successEmail = driver.findElement(By.id("user-email"));
            String displayedEmail = successEmail.getText();

            if ("validemail@example.com".equals(displayedEmail)) {
                LOGGER.info("Success email test passed!");
            } else {
                LOGGER.severe("Success email test failed! Displayed email: " + displayedEmail);
            }


            // Test dismissing the success message
            WebElement dismissButton = driver.findElement(By.id("btnDismissMessage"));
            dismissButton.click();

            // Wait for 4 seconds to observe the state after dismissing the success message
            Thread.sleep(4000);

            // Verify the sign-up form is displayed again
            WebElement signUpForm = driver.findElement(By.id("card-sign-up"));
            if (signUpForm.isDisplayed()) {
                LOGGER.info("Dismiss message test passed!");
            } else {
                LOGGER.severe("Dismiss message test failed!");
            }


            // Wait for 6 seconds before closing the browser
            Thread.sleep(6000);

        } catch (InterruptedException e) {
            // Log interrupted exception
            LOGGER.log(Level.SEVERE, "Interrupted exception occurred", e);
        }
        finally {
            // Close the browser
            driver.quit();
        }
    }
}

Note: In the script above, replace C:\\Selenium WebDriver Chrome\\chromedriver-win64\\chromedriver.exe with the path to the ChromeDriver executable on your machine.

Explanation of the Test Script for the `NewsletterSignUp` Website

To better understand how the Selenium WebDriver test script for the newsletter sign-up form works, we will examine each part of the code and explain its role.

WebDriver Initialization and Configuration

// Setup WebDriver
System.setProperty("webdriver.chrome.driver", "C:\\Selenium WebDriver Chrome\\chromedriver-win64\\chromedriver.exe");
WebDriver driver = new ChromeDriver();

This part of the code initializes and configures the WebDriver to use ChromeDriver.

java System.setProperty sets the path to the ChromeDriver executable on your machine.
WebDriver driver = new ChromeDriver(); creates a new instance of ChromeDriver, which is used to interact with the Chrome browser.

Bloc Try-Catch

try {
    // Selenium test code
} catch (InterruptedException e) {
    // Handle interrupted exceptions
    LOGGER.log(Level.SEVERE, "Interrupted exception occurred", e);
} catch (Exception e) {
    // Handle other unexpected exceptions
    LOGGER.log(Level.SEVERE, "An unexpected exception occurred", e);
} finally {
    // Close the browser at the end of the test
    driver.quit();
}

The try-catchblock surrounds the Selenium test code. It captures and handles exceptions that may occur during the test execution.
InterruptedException is specifically handled for interruptions during the use of Thread.sleep(), while Exception handles all other unexpected exceptions.
The finally block ensures that the browser is closed.

Navigation and Interaction with Page Elements

// Navigate to the form page
driver.get("https://newsletter-sign-up-with-success-message-challenge-tau.vercel.app/");

// Maximize the browser window
driver.manage().window().fullscreen();

driver.get()Navigates to the specified URL where the newsletter sign-up form is located.
driver.manage().window().fullscreen()Maximizes the browser window for better visibility and interaction during testing

// Locate page elements
WebElement emailInput = driver.findElement(By.id("email"));
WebElement submitButton = driver.findElement(By.id("btnSubmit"));

driver.findElement(By.id("email")) and driver.findElement(By.id("btnSubmit")) locate the page elements with the IDs email (email input field) et btnSubmit (form submission button).

Submitting Invalid Email

//Submit invalid email
emailInput.sendKeys("invalid-email");
submitButton.click();

emailInput.sendKeys("invalid-email") enters an invalid email into the email field.
submitButton.click() clicks the Submit button to submit the form with the invalid email.

Verifying Messages

// Check for the error message display
WebElement errorEmailMessage = driver.findElement(By.id("error-email"));
String errorMessage = errorEmailMessage.getText();
if ("Email is not in a valid format".equals(errorMessage)) {
    LOGGER.info("Invalid email test passed!");
} else {
    LOGGER.severe("Invalid email test failed! Error message: " + errorMessage);
}

driver.findElement(By.id("error-email")) locates the page element that displays the error message for an invalid email.
errorEmailMessage.getText() retrieves the text of the error message. The test checks if the expected error message is displayed and logs the result.

GitHub Project

For more practice, here’s the GitHub project that contains test scripts for the mini-projects written in JavaScript:.

Newsletter sign-up form with success message.
Time tracking dashboard.

Repository URL

Selinium_WebDriver_TestLogiciels_GitHub_Repository

Note: Please read the README.md file for details about this project.

Petite historique du langage Java

Melia Log — Thu, 04 Jul 2024 13:50:49 +0000

EN 1991, des ingénieurs de Sun Microsystems, regroupés en une équipe appelée équipe verte composée de:

James Gosling
Mike Sheridan
Patrick Naughton

décident de créer Java mais, sous forme d'un projet nommé "Oak" mais celui-ci fut un échec.
Par la suite Bill Joy ( cofondateur de la firme Sun Microsystems) propose une nouvelle version appelée Java

Pourquoi?:
Les ingénieurs cherchaient a concevoir un langage applicable à des petits appareils électriques ( on parle là de code embarqué).
Procédé:
Ils se sont basés sur une syntaxe proche du langage C++, en reprenant le concept de la machine virtuelle déjà exploité auparavant par le Pascal UCSD.
Idée:
L'idée consistait d'abord à traduire un programme source, non pas directement en langage machine mais, dans un pseudo langage universel disposant des fonctionnalités communes à toutes les machines ( notion de portabilité).

Ce code intermédiaire, appelé bytecode, se trouve ainsi compact et portable sur n'importe quelle machine, à condition que celle-ci dispose d'un programme approprié (machine virtuelle) permettant de l'interpréter dans un langage compréhensible par la machine concernée.

Définitions de mots clés:

Sun Microsystems:
Était un constructeur d'ordinateurs et éditeur de logiciels américain, racheté par Oracle Corporation le 20 Avril 2009 pour 7,4 milliards de dollars.
Notion de portabilité:
La portabilité d'un langage de programmation signifie que le code écrit dans ce langage peut être exécuté sur différentes plateformes et architectures sans nécessiter de modifications majeures.
C'est un aspect essentiel des langages de haut niveau comme le C, Java ou Python qui permettent aux développeurs de créer des applications multiplateformes plus facilement.
Bytecode:
Le bytecode est une représentation intermédiaire d'un programme source, souvent générée par des langages de programmation comme Java ou Python.
Contrairement au code source écrit par le développeur, le bytecode n'est pas directement exécutable par le processeur de l'ordinateur.
Il est plutôt destiné à être exécuté par une machine virtuelle (VM), telle que la Java Virtual Machine (JVM) pour Java ou la Python Virtual Machine (PVM) pour Python.

Quelques points supplémentaires pour l'exactitude historique et la clarté :

Java a été officiellement lancé par Sun Microsystems en 1995.
Oak a été renommé Java en raison d'un conflit de nom avec une autre technologie existante.
Java a été conçu avec la philosophie "write once, run anywhere" (écrire une fois, exécuter partout).

Forem: Melia Log

I left Windows for Ubuntu. Here’s everything I configured and what I learned

I left Windows for Ubuntu. Here’s everything I configured and what I learned

What I configured after installing Ubuntu

Installing and configuring Git

Install Git

Configure global variables

Java setup with SDKMAN (my first discovery)

What SDKMAN allows you to do :

Install SDKMAN

List available Java versions

Install Java 21 (example)

Switch Java version

Mind blow moment :

Node.js with NVM (another discovery)

What is NVM?

Why it matters (real case)

Install NVM

Install Node 20

PostgreSQL server + client

Install PostgreSQL

Check service

Change postgres password

PgAdmin 4

Postman via Snap

SSH Keys (BIG learning moment)

Create SSH key

Start SSH agent and add key

Copy public key

Add key to GitHub

Test connection

IDEs and account sync

Final thoughts

My Docker Adventure: A Journey to Containerization

My Docker Adventure: A Journey to Containerization

Why PostgreSQL and not MySQL?

Create Image

Table check

Resources That Helped Me Along the Way

Relationships in JPA: Creating Entities Without Dependency

Relationships in JPA: Creating Entities Without Dependency

Table of contents

Context and Problem:

Entity Modeling

Scenarios for Saving Data

Creating a Student without a ThesisSchedule

Updating the Student to Associate with a ThesisSchedule

Advantages of Managing the Relationship on Student's side:

Alternative: Managing the Relationship on the ThesisSchedule Side

Entity Modeling

Advantages of Managing the Relationship on ThesisSchedule’s Side:

Choosing the Right Configuration for Your Needs:

Write Good Commit Messages

Write Good Commit Messages!

Introduction: Why Commit Messages Matter

The Problem with Bad Commit Messages

Why is this a Problem?

The Solution: Use "Badges" to Structure Your Commits

Real-Life Examples of Good Commit Messages

Bonus: Tips for Writing Clear Commits

Recap

Conclusion

Explication de SeleniumWebDriver : Automatisez votre Flux de Tests Web

Table des matières

Qu'est ce que Selenium ?

Composants de Selenium

Selenium IDE:

Selenium RC:

Selenium WebDriver

Selenium Grid

Avantages et limites de Selenium WebDriver

Avantages de Selenium WebDriver

Limites de Selenium WebDriver

Architecture du Framework Selenium WebDriver

Processus d'exécution d'un test

Comment utiliser Selenium WebDriver avec Java?

Practical Introduction to Web Application Testing with Selenium WebDriver and Java.

A Practical Introduction to Web Application Testing with Selenium WebDriver and Java.

Setting Up the Environment

Installing Selenium WebDriver

Writing the Test Script for the `NewsletterSignUp` website

Explanation of the Test Script for the `NewsletterSignUp` Website