DEV Community: Olga Strijewski

How to Configure GitHub to Run Unit Tests Automatically

Olga Strijewski — Sat, 06 Jul 2024 05:43:59 +0000

Introduction

Setting up automated unit tests in GitHub can streamline your development process, ensuring code quality and reliability. This guide demonstrates how to create a simple Java project with unit tests and configure GitHub Actions to run these tests automatically.

You can check out the GitHub repository used for this project here: github-workflow-demo.

Creating a Project with Unit Tests

We will now create a simple Java project with a unit test. This will serve as the foundation for setting up automated unit testing in GitHub.

Generate Code Using Spring Initializr:

Open IntelliJ IDEA.
Go to File > New > Project.
Select Spring Boot and configure your project (Group, Artifact, etc.).
Choose "Spring Web" as a dependency.
Click Create, and IntelliJ IDEA will generate the project code for you.

This project can be found at github-workflow-demo GitHub repository.

Now we will "put some meat" into the project. Let's add a controller:

...and a unit test:

We will launch the application and see how it works. Right-click GithubWorkflowDemoApplication class and choose "Run 'GithubWorkflow....main()':

The application will start very quickly:

In a browser, navigate to http://localhost:8080/, and you will see the message "Hello, World!" as we programmed in our application:

Now let's launch the tests. Right-click GithubWorkflowDemoApplicationTests and choose "Run GithubWorkflowDemoApplicationTests:"

The tests are successful:

Great! You now have a simple application with a unit test. Don't forget to commit and push your new code to the repository.

Creating a Unit Test Workflow in GitHub

We will start with GitHub out-of-the-box template workflow for unit tests. Go to the "Actions" tab:

...and then click on the "New workflow" button:

Search for "test":

The very first option is what we are looking for - we have a Maven project. Click "Configure":

GitHub will generate a sample workflow for you:

After you check it in, it will run it. However, unfortunately, the default workflow fails:

You will need to add to it to make it succeed.

What's Wrong with the Out-of-the-Box Workflow?

Amazingly, the out-of-the-box workflow doesn't do any testing! I had to modify it as follows to make it run the tests:

I also added the surefire Maven plugin to pom.xml:

Now it actually runs the tests, however we still have errors.

Dependency Graph Errors

The errors are security related, and are about the dependency graph:

GitHub template has these lines at the end, that are indicated as "optional", and they are giving errors:

To fix the dependency graph permissions, let's create a personal access token with all the needed permissions. First, go to your profile > Settings:

Then navigate to "Developer Settings" at the bottom:

Create a personal access token. Make sure you check all the needed permissions:

Copy your token:

Then navigate to your repository's Settings > Secrets and variables > Actions, and create a secret with the name GH_TOKEN and the value - the token that you just created:

Add your token to the workflow configuration:

Now the workflow succeeds!

Testing the Workflow

Our workflow seems to be working well. Let's see what happens if our tests fail.

I made the test fail as follows:

Now when I launch them from the IDE, one of them fails:

After committing the changes, I found that the workflow also failed:

You can see the details, e.g., which tests failed and why, in the log:

I also see the failure in my email that is associated with my GitHub account:

Once I fixed the tests, the workflow was successful again:

Conclusion

By following this guide, you have successfully set up a simple Java project with unit tests and configured GitHub Actions to automate the testing process. This ensures continuous integration and helps maintain code quality as your project evolves.

How to Connect Your GitHub Project to Sonar

Olga Strijewski — Sat, 06 Jul 2024 04:17:02 +0000

Introduction

This guide will walk you through setting up SonarCloud for a GitHub project to automatically inspect code for bugs and vulnerabilities. Additionally, it covers common errors encountered during the setup process.

You can check out the GitHub repository used for this project here: github-workflow-demo.

Difference between SonarCloud and SonarQube

Sonar comes in two flavours - SonarCloud and SonarQube.

SonarCloud is a cloud-based service provided by SonarSource for continuous code quality and security inspection, ideal for projects hosted on GitHub, Bitbucket, or Azure DevOps. SonarQube, on the other hand, is a self-hosted solution that requires you to install and manage the server infrastructure, offering greater control and customization for larger or more complex projects. Both tools provide similar functionalities for analyzing code quality but cater to different hosting and infrastructure preferences.

We will use SonarCloud in this tutorial.

What are GitHub Actions and Workflows?

GitHub Actions is a powerful automation tool integrated into GitHub, enabling users to create custom software development workflows directly within their repositories. Workflows are defined in YAML files and can be triggered by various events, such as code commits, pull requests, or scheduled times. These workflows can include multiple jobs and steps to automate tasks like building, testing, and deploying code, thus streamlining the development and CI/CD (Continuous Integration/Continuous Deployment) processes.

Connecting Your Project to SonarCloud

Please have a look at this tutorial for detailed steps on how to establish a connection between your project on GitHub and SonarCloud: How to Enable SonarCloud for Your Project.

Setting Up a Sonar Action - Easy Way

Creating an action for automated SonarCloud checks seems very straightforward. Here is how GitHub suggests doing it...

Click on the "Actions" menu:

...then search for a Sonar action template:

We already discussed the difference between SonarCloud and SonarQube in an earlier chapter.

So, for our purposes, we are going to pick "SonarCloud." Click on the "Configure" button:

GitHub will create the workflow file for you in the correct directory in your repository, which you want to connect to SonarCloud. As you can see, it has some suggestions for next steps for you in the header of the file (enclosed in the red rectangle below), followed by the instructions in YAML format:

Theoretically, if you follow the steps, it will work. Of course, in the real world, each application is different and requires adjustments to this out-of-the-box script (as did my application - I will describe this below).

But first, let's follow the steps and see what we get.

The first two steps just tell us to connect our project to SonarCloud, which we did in How to Enable SonarCloud for Your Project mentioned above.

So, let's do step number 3.

Let's go to our SonarCloud application and click on "Information:"

We can copy our Project Key and Organization Key from the Information screen:

...and then paste them in the appropriate place in the YAML config file:

To generate the token, let's go to "My Account:"

...and then, in the "Security" tab, enter the name for the token and click on "Generate Token:"

It will generate your token, and as it says - you need to copy it right away because it will not show it to you anymore:

Then go back to GitHub, "Security" tab, Secrets and variables > Actions, and click on the "New repository secret:"

It says your secret should be named "SONAR_TOKEN." Enter your secret name and value (from your clipboard), and click "Add secret:"

Commit your YAML file to the repository:

Once you commit the workflow file, your project should be set up with Sonar. You can now go to the "Actions" tab and look at your first workflow.

Issues

As I mentioned before, I had a few issues with that out-of-the-box setup, and most of those issues will be applicable to anyone who attempts it. So, read on.

Disabling Automatic Analysis

My first workflow run resulted in a failure:

When we drill into the error, we will see the following:

The issue here is that, when you first configure SonarCloud, it by default enables automatic analysis. But once you configure it to be executed as part of a GitHub workflow, you will need to go to SonarCloud and disable that automatic analysis, so now it will only be analyzed once GitHub sends that request to SonarCloud.

To disable automatic analysis, in SonarCloud, go to Administration > Analysis Method:

...and switch off the toggle:

One issue down. Now the workflows succeed:

SCM Provide Detection Failed

In SonarCloud, I see a warning:

When I click on "See details," I see the following:

To fix that warning, go to Administration > General Settings:

Then, in "SCM" tab, "Key of the SCM provider for this project" - enter "git" and click "Save:"

After adding some code to the repository to actually give it some work, I started seeing new errors in the workflow.

Not inside a Git work tree: /github/workspace

This is the next error that I got. It indicates that SonarCloud is not recognizing the directory as a Git repository. This usually happens when the Git repository is not properly checked out or initialized in the workspace. You will need to update the workflow file to ensure the repository is checked out correctly. Add the following steps before the "Analyze with SonarCloud" step:

Input required and not supported: distribution

This next error that I got indicates that the "actions/setup-java@v2" action requires the distribution input, which specifies the Java distribution to be installed. To fix this issue, we need to provide the distribution input in the "actions/setup-java@v2" step:

Your project contains .java files, please provide compiled classes...

After fixing the above errors, I got this next one:

The error message indicates that your project contains *.java files and requires compiled classes to be provided with the sonar.java.binaries property, or these files need to be excluded from the analysis using the sonar.exclusions property.
To address this issue, I added this property into my sonar-project.properties:

sonar.java.binaries=target/classes

I set "target/classes" as the value because I have a Maven project.

I also added the compilation with Maven:

After that, my workflow was successful:

But is that all?

Configuring `sonar-maven-plugin`

I had an issue with the workflow being successful - actually, I introduced a Sonar bug on purpose in my code and wanted the workflow to fail because of this - but it was successful.

The log gave me a warning that SonarCloud recommends using sonar-maven-plugin instead of the regular SonarCloud workflow setup for Maven projects. So, I added the plugin to my pom.xml:

...and then removed all the template SonarCloud configuration and used sonar-maven-plugin instead:

That went well and got rid of the warning; however, the workflow was still successful, despite a Sonar bug in the code.

Sonar Quality Gate Passed When It Shouldn't

Here is the Sonar issue that I introduced on purpose:

And my workflow was successful:

I looked at SonarCloud, and amazingly, Sonar didn't consider my code to be an issue! The quality gate passed:

However, in "small type," it does say that the issue is that there are too few lines of code in my project (it is just a small sample project):

So, I increased the number of lines - I generated that same issue 10 times:

Then I was able to see the quality gate fail:

However, the workflow still succeeded:

But this is the subject of the next subsection.

Workflow Should Fail When Sonar Analysis Is Not Successful

To make the workflow fail wherever the quality gate fails, we need to add a step in our GitHub Actions workflow that checks the quality gate status after the SonarCloud analysis is complete. This can be done using the SonarCloud API.

I added the following lines to the YAML file to do that:

That worked, and the workflow failed. If you drill down to the failure, it will tell you the reason - the failure is because the quality gate didn't pass:

I also got a failure email to the email account associated with my GitHub repo:

Conclusion

By following this guide, you can successfully set up SonarCloud to automatically analyze your GitHub project for bugs and vulnerabilities. Implementing these steps ensures that your code quality and security are maintained, helping you catch issues early in the development process. As a next step, you can explore more advanced SonarCloud features and further customize your workflows.

How to Enable SonarCloud for Your Project

Olga Strijewski — Sat, 06 Jul 2024 01:27:14 +0000

Introduction

In this guide, we will walk through setting up SonarCloud for a GitHub project to automatically inspect code for bugs and vulnerabilities. This will help ensure code quality and security in your project.

Initial Setup of SonarCloud

I already have a project on GitHub, and I would like to enable SonarCloud on it to automatically inspect the code for bugs and vulnerabilities. Here is my project:

To enable SonarCloud, let's first open the following URL: http://sonarcloud.io, which will redirect to https://www.sonarsource.com/products/sonarcloud/. Then click on the "SIGN UP" button:

This will redirect you to GitHub, where you will enter your username and password:

...and then give SonarCloud certain permissions:

SonarCloud will ask you to configure your GitHub organization:

Once you click on "Import an organization," it will ask you if you want to import all the repositories of that organization or only the selected ones. I will only import one repository:

After clicking the "Install" button, it will ask a few more questions:

Then choose the free plan - you can do that as long as your repository is a public repository:

The next step is analyzing your projects. At this point, there is only one organization available - the one you just created. You can select the project to analyze from your GitHub projects that you agreed to import earlier, and then click the "Set Up" button:

A few more additional settings about how you want your project analyzed - select whether to analyze once the new version appears or analyze once a certain number of days passes. I chose the first option and then clicked on "Create project":

That's all SonarCloud needed to start analyzing the code. Now it brings you to the dashboard, and you need to wait for it to finish its first analysis:

Analysis Result

Voilà! The first analysis of my project is done. It found one issue (it is a little sample project):

We can click on that issue to see the details:

...and we can drill down even more once we click on the issue description, including the code snippets:

Now you've connected your project to SonarCloud! For most languages, it will run automatic analysis, so every time anything changes, your results will be up to date.

Conclusion

With SonarCloud set up, you can now enjoy automatic code quality checks for your GitHub projects. This ensures that your code remains secure and free from vulnerabilities. As the next step, you can configure Sonar as an automatic workflow in GitHub or other systems to maintain high code quality.

How to Create and Upload Your First Project to GitHub

Olga Strijewski — Wed, 03 Jul 2024 20:57:11 +0000

Introduction

Creating and uploading your first project to GitHub is a fundamental skill for any developer. It provides a platform to collaborate with others, track changes, and showcase your work. This guide will walk you through the process of generating a Java project using Spring Initializr and pushing your project to GitHub. By the end of this article, you’ll have your project up and running on GitHub, ready for collaboration and version control.

Approaches to Creating and Uploading a Project to GitHub

There are two common approaches to creating and uploading a project to GitHub. You can either create the project on GitHub, check it out, generate the code on top of it, and then push it to GitHub, or generate the code first and then upload it to GitHub. Both methods are effective, and the choice depends on your workflow preference. Below are the detailed steps for each approach.

Option 1: Create Project in GitHub, Check It Out, Generate Code on Top, Then Push to GitHub

Create a New Repository on GitHub:
- Go to GitHub and create a new repository.
- Fill in the repository details, you may also select the options to include a README.md, .gitignore, and optionally a license.
Clone the Repository Locally:
- You can do it either via IntelliJ, via File > New > Project, or using the "git clone" command from the command line.
Generate Code Using Spring Initializr:
- In IntelliJ IDEA, go to File > New > Project.
- Select Spring Initializr and configure your project (Group, Artifact, Dependencies, etc.).
- Ensure you select the directory where you cloned the GitHub repository as the project location.
Add and Commit Generated Code:
- Open the terminal in IntelliJ IDEA or your preferred terminal.
- Navigate to your project directory.
- Add the generated code to your local repository:
```
git add .
git commit -m "Generated initial code using Spring Initializr"
```
Push Changes to GitHub:
- Push the changes to the GitHub repository:
```
git push origin <your code branch>
```

Option 2: Generate Code First and Then Upload to GitHub

Generate Code Using Spring Initializr:
- Open IntelliJ IDEA.
- Go to File > New > Project.
- Select Spring Boot and configure your project (Group, Artifact, Dependencies, etc.).
- Click Create, and IntelliJ IDEA will generate the project code for you.
Initialize Local Git Repository:
- Open the terminal in IntelliJ IDEA or your preferred terminal.
- Navigate to your project directory.
- Run the following commands to initialize a local Git repository:
```
git init
git add .
git commit -m "Initial commit"
```
Create a New Repository on GitHub:
- Go to GitHub and create a new repository. The name of your new repository can be the same as your project directory name, but it doesn't have to be.
- Fill in the repository details, and you can also select the options to include a README.md, .gitignore, and optionally a license.
- Do not add any other files as they might conflict with your local repository.

Push Local Repository to GitHub:

In your terminal, link your local repository to the GitHub repository and push the code:

git remote add origin <your GitHub repo URL>
git pull origin <GitHub branch> --allow-unrelated-histories
git push -u origin <your code branch>

(The --allow-unrelated-histories option in Git is used when merging two branches that do not share a common base commit. By default, Git prevents merging histories that have no common ancestor to avoid accidentally combining unrelated projects. The --allow-unrelated-histories flag allows this merge to proceed.)

Conclusion

By following the steps outlined in this guide, you have successfully created a Java project with Spring Initializr and pushed your project to GitHub. While this guide focused on a Java project, the principles and steps are applicable to a wide range of programming languages and frameworks. Now that your project is on GitHub, you can easily share it with others, manage contributions, and maintain a robust development workflow.

How to Install (and Uninstall) MySQL on a Mac

Olga Strijewski — Mon, 10 Jun 2024 00:15:51 +0000

Introduction

In this tutorial, we will walk you through the actions necessary to perform on a Mac to install MySQL.

There are two methods that can be used:

download the installation package from Oracle and launch the installer file, or
install using homebrew.

Since the first method is pretty straight-forward, we will take up the second one and describe it in more detail - installation of MySQL using homebrew. Even though it may seem a bit more complicated, after that you will have more control over your installation and various options.

At the end of the tutorial, we will also learn to clean MySQL out of your system on a Mac.

Installing and / or Updating Homebrew

If you don't have Homebrew yet on your Mac, please install it using the following command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Before any new installation, it is recommended to update Homebrew package manager itself. The below command fetches the latest version of the Homebrew core and all the formulae (package definitions) from the official repository. This ensures that you have the most recent information about available software packages and their versions.

To update Homebrew - execute the following command:

brew update

Installing and Running MySQL Using Homebrew

To install MySQL using Homebrew, run the following command:

brew install mysql

Once the installation is complete, use the following to run MySQL:

brew services start mysql

And, here are the corresponding commands to stop and to restart MySQL:

brew services stop mysql

brew services restart mysql

Securing MySQL Installation

Next, you must secure your MySQL installation, this is a required step.

To do this, execute the following command:

mysql_secure_installation

Here is how I ran this command in my terminal and what options I used / how MySQL replied:

olgastrijewski@MacBook-Pro ~ % mysql_secure_installation

Securing the MySQL server deployment.

Enter password for user root: 

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: No
Using existing password for root.
Change the password for root ? ((Press y|Y for Yes, any other key for No) : No

 ... skipping.
By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) : Yes
Success.


Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Yes
Success.

By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.


Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Yes
 - Dropping test database...
Success.

 - Removing privileges on test database...
Success.

Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Yes
Success.

All done!

Command `mysql_secure_installation` not Available

Sometimes, after the installation of MySQL, you will find that this command is not available. Then you can restart your Terminal, to make sure that all settings are applied, or even restart your computer if needed. If this doesn't help, then try searching for the mysql_secure_installation script in the /usr/local directory as follows:

find /usr/local -name "mysql_secure_installation"

If you can't find it, then try searching in other common locations:

ls /usr/local/opt/mysql@8.0/bin
ls /usr/local/bin

If you still can't find it, then it is possible to secure the installation without this script, by issuing direct commands in MySQL command-line interface. Here are the commands that I issued together with MySQL responses:

olgastrijewski@MacBook-Pro ~ % mysql -u root
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.0.37 Homebrew

Copyright (c) 2000, 2024, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY 'my-password';
Query OK, 0 rows affected (0.01 sec)

mysql> DELETE FROM mysql.user WHERE User='';
Query OK, 0 rows affected (0.00 sec)

mysql> DELETE FROM mysql.user WHERE User='root' AND Host!='localhost';
Query OK, 0 rows affected (0.00 sec)

mysql> DROP DATABASE IF EXISTS test;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> DELETE FROM mysql.db WHERE Db='test' OR Db='test\\_%';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

mysql> exit;
Bye

Installing MySQL Workbench

MySQL Workbench makes it easy and visual to work with the MySQL installation, creating database schemas and issuing SQL queries to them.

Again, you can install MySQL Workbench by downloading it from Oracle. But here we will install it using Homebrew.

MySQL Workbench is a "cask" in Homebrew, meaning it is a visual UI application and not a command-line tool.

To install MySQL Workbench using Homebrew, issue the following command:

brew install --cask mysqlworkbench

Then you can run it from your Applications folder as usual:

Installing a Specific Version of MySQL

The command from the previous section - will install the latest version of MySQL. Sometimes you may want to install one of the previous versions, or even have several versions installed, so you can choose which one to run.

If you'd like to install a particular version, which is not the latest version, then you can do this as follows (for example, to install MySQL version 8.0):

brew install mysql@8.0

You will then need to specify which version of MySQL you need to start, stop or restart in the following commands:

brew services start mysql@8.0

brew services stop mysql@8.0

brew services restart mysql@8.0

If you want to see which versions are available for installation, use the following:

brew search mysql

This command will list all formulae related to MySQL. You might see output similar to this:

==> Formulae
mysql        mysql@5.6    mysql@5.7    mysql@8.0

==> Casks
mysqlworkbench

In the next section, we will be entering the MySQL command-line interface (CLI), and if you did install a specific non-latest version of MySQL, then you will need to run the following command before entering the CLI:

brew link --force --overwrite mysql@8.0

This will ensure that the MySQL binaries are properly linked in your system's PATH, making it easier to run MySQL commands from the command line without specifying the full path.

Command-Line Interface (CLI)

When you want to connect to MySQL command-line interface, use the following command:

mysql -u root -p

It will ask you for a password - enter the one that you provided when you were securing MySQL installation.

If the login is successful, then you’ll see a prompt like this:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.0.25 Homebrew

Copyright (c) 2000, 2021, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

In the MySQL console, you can run SQL commands. For example:

SHOW DATABASES;

This command lists all databases on the MySQL server. Each command should end with a semicolon (;).

To exit the MySQL console, you can type:

exit;

Or use the shortcut:

\q

Uninstalling MySQL

Sometimes you will want to clean MySQL out of your MacOS system completely. For example, I did that when I had MySQL installed using the package installer, but I wanted to reinstall it using Homebrew.

Here are the commands you will need to run to do this:

sudo rm -rf /usr/local/mysql*
sudo rm -rf /Library/PreferencePanes/My*
sudo rm -rf /etc/my.cnf
sudo rm -rf /etc/my.cnf.d
sudo rm -rf /usr/local/var/mysql
sudo rm -rf /Library/Receipts/mysql*
sudo rm -rf /Library/Receipts/MySQL*
sudo rm -rf /private/var/db/receipts/*mysql*
sudo rm -rf /Library/Preferences/com.oracle.mysql.*
sudo rm -rf /Library/Logs/MySQL*

Then remove any references to MySQL from your ~/.bash_profile and ~/.zshrc:

sudo nano ~/.bash_profile
sudo nano ~/.zshrc

Check your $PATH variable to make sure it doesn't have any references to MySQL:

olgastrijewski@MacBook-Pro ~ % echo $PATH
/Users/olgastrijewski/.rvm/gems/ruby-2.7.2/bin:/Users/olgastrijewski/.rvm/gems/ruby-2.7.2@global/bin:/Users/olgastrijewski/.rvm/rubies/ruby-2.7.2/bin:/Users/olgastrijewski/.gem/ruby/2.7.0/bin:/usr/local/opt/openssl@1.1/bin:/Users/olgastrijewski/.sdkman/candidates/maven/current/bin:/Users/olgastrijewski/.sdkman/candidates/java/current/bin:/Users/olgastrijewski/.sdkman/candidates/ant/current/bin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin:/Users/olgastrijewski/.cargo/bin:/Users/olgastrijewski/.rvm/bin
olgastrijewski@MacBook-Pro ~ %

These commands will effectively clean MySQL completely out of your system.

Conclusion

Installing MySQL on a Mac using Homebrew provides a flexible and powerful method for managing your database setup. While the initial steps might seem more complex than using a standard installer package, the control and customization options available through Homebrew are invaluable. This tutorial has guided you through the entire process, from installing Homebrew itself to securing your MySQL installation, installing MySQL Workbench, and even cleaning MySQL from your system if needed. By following these steps, you ensure a robust and secure MySQL environment on your Mac, tailored to your specific development needs.

DEV Community: Olga Strijewski

How to Configure GitHub to Run Unit Tests Automatically

Introduction

Creating a Project with Unit Tests

Creating a Unit Test Workflow in GitHub

What's Wrong with the Out-of-the-Box Workflow?

Dependency Graph Errors

Testing the Workflow

Conclusion

How to Connect Your GitHub Project to Sonar

Introduction

Difference between SonarCloud and SonarQube

What are GitHub Actions and Workflows?

Connecting Your Project to SonarCloud

Setting Up a Sonar Action - Easy Way

Issues

Disabling Automatic Analysis

SCM Provide Detection Failed

Not inside a Git work tree: /github/workspace

Input required and not supported: distribution

Your project contains .java files, please provide compiled classes...

Configuring sonar-maven-plugin

Sonar Quality Gate Passed When It Shouldn't

Workflow Should Fail When Sonar Analysis Is Not Successful

Conclusion

How to Enable SonarCloud for Your Project

Introduction

Initial Setup of SonarCloud

Analysis Result

Conclusion

How to Create and Upload Your First Project to GitHub

Introduction

Approaches to Creating and Uploading a Project to GitHub

Option 1: Create Project in GitHub, Check It Out, Generate Code on Top, Then Push to GitHub

Option 2: Generate Code First and Then Upload to GitHub

Conclusion

How to Install (and Uninstall) MySQL on a Mac

Introduction

Installing and / or Updating Homebrew

Installing and Running MySQL Using Homebrew

Securing MySQL Installation

Command mysql_secure_installation not Available

Installing MySQL Workbench

Installing a Specific Version of MySQL

Command-Line Interface (CLI)

Uninstalling MySQL

Conclusion

Configuring `sonar-maven-plugin`

Command `mysql_secure_installation` not Available