DEV Community: Mateus Daniel

My challenges until release my first dart package at pub.dev and how you can make it too

Mateus Daniel — Fri, 10 Feb 2023 03:42:46 +0000

As part of a Flutter developer routine, in my last four years I was very familiar with widgets components to make the UI, and some business logic of course, so now I've decided to dive into some pure dart code and maybe learn something different this time.

Reason and the path

Sometimes I used to do some projects using only dart since I want to automatize little tasks in my day as a programmer, in my job I act as a Tech Lead, and one of my main tasks is to standardize the workflow of mobile developers, setting best practices and also architectural models. To reach all of them the first thing was to make use of a pattern to make commits more understandable, to reach this objective we use the conventional commits, with that we easily make the message commits work as we want, in this article I will focus on that point, so to grant that the commits will be sent with this pattern I've decided to create a little dart project to make it.

After working on that for a while I've finally published it at pub.dev you can check here: git_helper, but that's not all, as part of this article I show the basics starting from creating a dart project until publishing it.

Get started

Consider that you already have the dart on your O.S, if not, download it from Dart SDK, with that configured you can check if everything is set up with the command dart --version, if this return a dart version so you have successfully install it on your computer.

With that configured let's create a new dart project with the command dart create my_project where my_project is your project name, so you can give any name that you want, if you are a flutter developer can notice that the project structure is a little bit different, the main folders are:

bin: where you have your code entry point with the main() function.
lib: here you can write all your logic code that makes things happen.
test: this folder, as the name said, it's used to put all your test codes, to test then just type dart test

After you write your code, you can start the process to publish it, there are some important points to notice here, the main one says that once you publish you can't delete, cause may impact if someone is using it, to make things happen we can use the command dart pub publish --dry-run, with that we can see a report of what's missing to start the publication, the major points are:

pubspec.yaml: in this file, you should declare some points like the name, version, description, and platforms, you can take this as an example:

name: my_project
version: 1.0.0

description: A simple dart project
repository: https://github.com/your_name/your_repository

environment:
  sdk: '>=2.18.6 <3.0.0'

dev_dependencies:
  test: ^1.16.0

dependencies:
  interact: ^2.1.1

executables: 
  my_project: 

platforms:
  linux:
  macos: 
  windows:

README.md: in this markdown file you should give instructions on how to use your project, here try to cover all that your code does.
CHANGELOG.md: this is also a markdown file, every version that will be published should be described here with your changes, you can take this as an example:

## 1.0.0

- My first project release.
- Implement my amazing feature

and the last one, but also very important is the license, probably your project doesn't have this file by default, which means you should know what kind of license you want to use for the project, there are many types like GPL, MIT, and BSD each one has your own rules, like an open source project, I will give an example using the MIT license:

The MIT License (MIT)

Copyright (c) [year] [full name of copyright owner]

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

is strongly important that you know what your license grant and why you opted for it.

Publishing

After all these steps, is finally time to publish your dart code as a package, to do that is more simple than all the processes before, but first, you should have an account on the platform, to make sure just go pub.dev and click on sign in button, now it's time to make the magic happen, just type dart pub publish, if is your first time the terminal, will appear a link to authenticate with you user, after that, all the upload process will be done automatically and that's it, just pay attention that your project will be revised, this process could take a while, in my case 30 minutes, after that, you have your package on pub.dev and ready to share with anyone in the world :).

Considerations

Since I've planned to create this git helper project and share it on pub.dev to help me and my teammates, you could have many opportunities to make something cool that could help someone, with all that said, really hope you have understood and enjoyed this journey, see you next time.

My final project is the git_helper, you can download my package and try it, if you want to improve, PRs are always welcome.

Testing your Flutter app

Mateus Daniel — Thu, 02 Feb 2023 20:11:29 +0000

Hello everybody, today we're gonna talk about tests with flutter and the importance of doing that in your projects, so let's get started.

Why do we need to test?

As our flutter project grows the importance of testing it grows too, so since your code was well made using good patterns and following the best practices, it makes easier to implement a test to grant you the app works as you've projected for.

Concept

There are some concepts of how to write tests and provide better and well-projected apps, one of the most common is the TDD (Test Driven Development), which says that you have to write your test first and then write the code, and repeat the process of how many times you need to ensure that everything is passing in test and the code only does what it has to do.

Types of test

With Flutter we have three types of tests, they are:

Unit test: as the name said, this kind of test has the purpose of checking if the minimum part of your code is working as expected, this includes for example functions and classes.
Widget test: This one verifies if the widgets are working as expected, so the purpose of this kind of test is to check the UI consistency.
Integration test: The last one, the integration test, it's personally my favorite type, this is like a mix of the two types of the test described before, with this you can check an entire flow, so you can verify if the checkout of an e-commerce app is working as expected for example.

With all that said let's dive inside some examples to understand a little bit better. In this case, I will show how to test a login because it is a common feature for most of the projects.

To get started, suppose that you've already the flutter in your O.S then just create a project with the command flutter create login_test where the name login_test can be changed if you wanna give another name for your project, with this created verify in your root directory and you be able to find a folder called test, all of your testing code should be inside that and by default, all the classes created for this purpose have to be in the the _test.dart to let the language recognize this as a test class.

To get started using the TDD concept, let's create the unit test first before the implementation.

Unit test

delete the file that comes with the project and create a file called unit_login_test.dart in test folder with the following code:

import 'package:flutter_test/flutter_test.dart';

void main() {
  group('Login controller', () {
    test("success login", () {
      LoginController controller = LoginController();
      expect(controller.login("username", "password"), true);
    });

    test("failed login", () {
      LoginController controller = LoginController();
      expect(controller.login("invalidUsername", "invalidPassword"), false);
    });
  });
}

We create a main function, which starts in this case these tests, we have to import the class flutter_test to execute as we want, to do this we create a group and inside put all our test cases, initiate our class and execute the function with some given parameters, and the expected return in expect test function to do that we imagine that we have a controller and inside a login function that receives the username and the password and if match returns a boolean. To execute now we have to create a file called login_controller.dart inside the lib folder with the following code:

class LoginController {
  bool login(String username, String password) {
    return username == "username" && password == "password";
  }
}

With that, we only have to import this class inside our test class and execute it to see the result

import 'package:login_test/login_controller.dart';

Now let's move to the second type of test

Widget test

Like the unit test, we will create the test file and implement that, to get started create a file called widget_login_test.dart and put the following code:

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';

void main() {
  testWidgets("Login UI", (tester) async {
    await tester.pumpWidget(const MaterialApp(home: LoginPage()));

    final username = find.byKey(const Key("usernameTextField"));
    final password = find.byKey(const Key("passwordTextField"));
    final loginButton = find.byKey(const Key("loginButton"));

    expect(username, findsOneWidget);
    expect(password, findsOneWidget);
    expect(loginButton, findsOneWidget);

    await tester.enterText(username, "username");
    await tester.enterText(password, "password");
    await tester.tap(loginButton);

    await tester.pump();
    final successMessage = find.byKey(const Key('success'));
    expect(successMessage, findsOneWidget);
  });
}

The widget test renders the widgets and you can perform actions like tap() and enterText() to interact with the components, in this test case we need to search using the Key parameter, you can do it using a text, but the Key gives you more confidence about getting the right thing. Now to implement the code just create a file called login_page.dart and put this code below:

import 'package:flutter/material.dart';
import 'package:login_test/login_controller.dart';

LoginController loginController = LoginController();

TextEditingController usernameController = TextEditingController();
TextEditingController passwordController = TextEditingController();

class LoginPage extends StatelessWidget {
  const LoginPage({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          TextField(
            controller: usernameController,
            key: const Key('usernameTextField'),
          ),
          TextField(
            controller: passwordController,
            key: const Key('passwordTextField'),
          ),
          const SizedBox(height: 16),
          ElevatedButton(
            key: const Key('loginButton'),
            child: const Text("Login"),
            onPressed: () {
              // Example login logic
              if (loginController.login(
                  usernameController.text, passwordController.text)) {
                showDialog(
                  context: context,
                  builder: (_) => const AlertDialog(
                    key: Key('success'),
                    title: Text("Login Successful"),
                  ),
                );
              }
            },
          ),
        ],
      ),
    );
  }
}

Now we only need to import the LoginPage in our widget test file, just type import 'package:login_test/login_page.dart'; with that you can execute your test and should see something like

Integration test

This is the last type of test, it works by executing a complete feature, to do that you need a real device, to start we need to add a new dependency in our file pubspec.yaml in the section dev_dependencies called integration_test: sdk: flutter, after this just type flutter pub get to update the dependencies, with this set up complete you need to create a folder called integration_test in the root directory, then insert a file who you can call app_test.dartwith the code below:

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:login_test/login_page.dart';

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
  WidgetsFlutterBinding.ensureInitialized();
  group('LoginPage', () {
    testWidgets("Login UI", (tester) async {
      await tester.pumpWidget(const MaterialApp(home: LoginPage()));

      final username = find.byKey(const Key("usernameTextField"));
      final password = find.byKey(const Key("passwordTextField"));
      final loginButton = find.byKey(const Key("loginButton"));

      expect(username, findsOneWidget);
      expect(password, findsOneWidget);
      expect(loginButton, findsOneWidget);

      await tester.enterText(username, "username");
      await tester.pumpAndSettle(const Duration(seconds: 1));
      await tester.enterText(password, "password");
      await tester.pumpAndSettle(const Duration(seconds: 1));
      await tester.tap(loginButton);

      await tester.pumpAndSettle(const Duration(seconds: 1));
      final successMessage = find.byKey(const Key('success'));
      expect(successMessage, findsOneWidget);
    });
  });
}

this code is very similar to the widget test, but we have a few differences, we use IntegrationTestWidgetsFlutterBinding.ensureInitialized(); and WidgetsFlutterBinding.ensureInitialized(); to ensure that we have the integration test and the widgets ready to start the process.

Bonus

With an additional part of this article, we gonna see how to get a visual report of the test coverage, if you don't wanna learn this just skip to the conclusion.

to do that we have to run in terminal flutter test --coverage, after executing this should create a folder called coverage with a file named lcov.info inside as we see below:

after that you have to convert this file into a bunch of files to be read by a web server, to continue just type in your terminal genhtml coverage/lcov.info -o coverage/html where the coverage/lcov.info is the path of the file created above and the coverage/html after the flag -o is the directory where I want to save the generated files when this part finish, you will see a folder with the given name created where you choose.

to finish we have to expose this directory to access in a web browser, to do that I recommend getting the dhttpd library from here just type in your terminal dart pub global activate dhttpd with this you've downloaded the library globally, after this just type dhttpd --path coverage/html/ and open a browser to put the URL http://localhost:8080 and finally you will be able to see a full report about your test like you see bellow:

With this we finish the bonus part, this could be essential to understand where the code is not covered and where the tests are failing.

Conclusion

As we see, the tests give us more confidence in the final result focus on the release, this process can take more time to finish a feature, but the gain with that is more valuable than if a bug was reported after distribute of the project, so hope everybody understands how to do and the importance, hope to see you next time.

If you wanna see the full code, i've uploaded the code, the link is: Repository

How to prevent bad commits and test code with lefthook and integrate with Flutter

Mateus Daniel — Fri, 17 Jun 2022 19:20:35 +0000

Lefthook is a tool to give us more confidence in our commits, it work with a lot of programming languages and Frameworks such as Flutter, Go, Ruby, and many others, and even can execute some tasks like lint and test, with that said let's configure this to work with.

To get started it depends on your O.S, with Linux distributions like Ubuntu and Debian you have two different ways to do that

using curl:

curl -1sLf 'https://dl.cloudsmith.io/public/evilmartians/lefthook/setup.deb.sh' | sudo -E bash
sudo apt install lefthook

If you don't have curl installed just type: sudo apt install curl

using Snap: you just have to type: snap install --classic lefthook

If you are using a macOS, you can try with Homebrew, to do that just: brew install lefthook

After this step, you should have the lefthook installed on your machine, let's see how to use it

To use in your project you have to go to the terminal and then move it to root, after that you have to type: lefthook install and a file named lefthook.yml has to be created in your project, in this example I created a Flutter project and execute the command, you can see the result below:

You can set some instructions at some moment of the commit process such as pre-commit, pre-push, and commit-msg, these instructions will be executed depending of what commit process they are inside, let me show an example:

pre-commit:
  parallel: true
  commands:
    tests:
      run: flutter test
    analyze:
      run: flutter analyze

In this code block above I'm executing some tasks in parallel before the commit process is done, in that case, I'm running the Flutter test and analyzing and the commit will be finished only if these tasks have been completed, let's have another example

pre-push:
  parallel: true
  commands:
    tests:
      run: flutter test

Now, with this code block above the task will run only when the push process has been started, in this case, I'm executing some Flutter test and the commit only will be done will all tests have been completed with success

To finish, let's learn how to use the commit-msg block, in our case we will check the commit message using as a base the conventional commits spec, if you don't know about this concept you can click here, so let's move, in this example, we have to create a folder called bin and inside then create a file called commit_message.dart, the result should be

Inside bin/commit_message.dart file, we can insert the below code

import 'dart:io';

dynamic main() {
  final rootDir = Directory.current;
  final commitFile = File("${rootDir.path}/.git/COMMIT_EDITMSG");
  final commitMessage = commitFile.readAsStringSync();

  final regExp = RegExp(
    r'(bugfix|feature|hotfix|none|chore|refactor|doc|style|test)(\(\w+\):\s?)(\[\w+-\d+])(.+)',
  );

  final valid = regExp.hasMatch(commitMessage);
  if (!valid) exitCode = 1;
}

This file basically gets the commit message and then passes a regex to check if they are in concern with the conventional commits, finally in our lefthook.yml file we can put

commit-msg:
  commands:
    validate:
      run: flutter pub run bin/commit_message.dart

With that, we execute the file created to check with lefthook if the message commit has matched with what was expected, in my case the final looks like

pre-commit:
  parallel: true
  commands:
    tests:
      run: flutter test
    analyze:
      run: flutter analyze
    lint_code:
      glob: '*.dart'
      run: dart fix --dry-run lib && git add .
    format_code:
      glob: '*.dart'
      run: flutter format {staged_files} && git add .       

commit-msg:
  commands:
    validate:
      run: flutter pub run bin/commit_message.dart

For now, you've learned how to integrate this tool to keep your commits more safe and clean with clear messages, I hope that you liked it and see you in the next article.

Lefthook repo

CI with SonarQube and Flutter - Part 2

Mateus Daniel — Wed, 15 Jun 2022 17:02:07 +0000

This is the second part of the article, to go to the first one just click here

Welcome back to everyone, in this second part as I said at the end of the last article we will download Docker and the SonarQube image, so let's go.

We should start going to Docker Desktop and the website will show something like:

In my case the downloaded version will be the mac with an apple chip (arm architecture) because I'm using the m1 processor, if you're using a different O.S is just change go to Docker for windows or Docker for linux and proceed with the installation in mac after download just move the docker app to Applications folder like the image below:

When the installation process is done you have to open the docker application and probably should see something like:

Now we have a Flutter project created and the Docker downloaded, the next step is to download the SonarQube software, in this tutorial will be used the image to containerize, and for that, we have to open the SonarQube Download page, with that open you will see:

Now to download the image to use with docker just click on the Available From DockerHub button to move to the next page, when the load is finished move down a little bit until seeing something like the image below:

When reached this part I have some notes to give, first of all, we will use the community edition because is open source and is enough for this tutorial proposal, the second point, users with a processors like Intel and AMD just need to type docker pull sonarqube:9.5-community and download the official version, for users like me who use an ARM processor there is not an official version and for that, we have some trusted options to keep moving this tutorial, just type docker pull mwizner/sonarqube, with that you should be able to download an image of version 9.4 who was made to this specific processor type.

With the image downloaded, we go back to Docker and in the Images option we can see that like:

We can also check type in terminal docker images, and see something like:

REPOSITORY                                    TAG               IMAGE ID       CREATED        SIZE
mwizner/sonarqube                             8.9.5-community   f5e2e7d2d122   5 months ago   521MB

Probably you will see just one image, and that's the option you chose, right now we should create a container with this image, and for that, we need to type in terminal:

docker create --name sonarqubeapp -p 9000:9000 f5e2e7d2d122

Where in parameter --name we can give a name for our container in -p we pass the 9000 port and finally, we should pass the image id, in that case, f5e2e7d2d122, after running this command we can move to container option in Docker Desktop and see something like this image:

In this option you will notice that now we have a container created with the SonarQube image, now just run the container to start the software, for that we can just click the start button in the container created or just type docker start sonarqubeapp in the terminal, where sonarquebeapp should be the name of the container.

While the container is opening you can open your browser and type http://localhost:9000/, after starting you will be able to see the login page:

By default to log in for the first time, just type admin in the login and password fields, you will be redirected to the home page and will see that:

At that point I have to give a note, Dart and Flutter are not supported officially by SonarQube yet, so for that reason, we need to download a plug-in that will do the work we need, to do that we have to open this repository and go to releases page to download the last version, until this article date the version is 0.4.0. after downloading the .jar we move to the download folder in terminal type:

docker cp sonar-flutter-plugin-0.4.0.jar sonarqubeapp:/opt/sonarqube/extensions/plugins

With this command we copy the .jar file to our container, after that we need to restart to see the changes, just type docker restart sonarqubeapp and wait for it.

Log in again and to check if the plug-in was correctly installed click on the administration tab, later click on the Marketplace tab inside the admin options, and finally in Plugins click on Installed to see the page like:

With all that set up we now have to download the last thing (i promise this will be the last 😅), this will be the scanner to show our reports locally, to do that go to Sonar Scanner Download, after download unzip the file in any folder you want, I recommended to do that in your home folder.

Now you will have to add the path in your .bash_profile or .zshrc (or in environment variables in windows), it depends on what kind of terminal you use, type: export PATH="$HOME/sonar-scanner-4.7.0.2747-macosx/bin:$PATH".

To finish now we have to set up our flutter project to export the reports to Sonar, to start the configuration we open our project and then create a file on root called sonar-project.properties, and inside that you should put:

# Project identification, either hardcode it or use Environment variables
sonar.projectKey=my-project-key
sonar.projectName=Project Name
sonar.login=my-long-token

# The host URL
sonar.host.url=http://localhost:9000

# Source code location.
# Path is relative to the sonar-project.properties file. Defaults to .
# Use commas to specify more than one folder.
sonar.sources=lib
sonar.tests=test

# Encoding of the source code. Default is default system encoding.
sonar.sourceEncoding=UTF-8

# exclude generated files
sonar.exclusions=test/**/*_test.mocks.dart,lib/**/*.g.dart

With this file created, go back to the SonarQube home page, and let's create a project manually, to do that just click on Button Add Project and the click the Manually option:

Next, we give a project key and a display name to the project and click on the setup button, next page the Sonar will ask you to generate a token, so create a name for your token and click in generate, this will show you a token, you need to copy and go back to sonar-project.properties file and fill the projectKey, projectName and token with what was provided.

With this file created and configured, we run some commands to store the tests and report to Sonar:

flutter test --machine --coverage > tests.output
sonar-scanner

When finishing this, you can refresh your SonarQube page to see the app insights:

In your homepage will have a banner and when you click on then you can see more feedback about your project like the image below:

With all this configured you will be able to get all the information needed to improve your code, with this part finished, hope you enjoy it, and feel free to comment.

Bonus: I will make a new article to level up this integration using pipelines in the remote repository and ngrok, as soon as I post I will put the link here, for now, that's all, thanks for everyone.

CI with SonarQube and Flutter - Part 1

Mateus Daniel — Tue, 14 Jun 2022 20:16:37 +0000

Hello everybody, this is my first article, so feel free to comment on how can i get better, I will appreciate it.

In this article, I will show how to use the SonarQube tool with the Flutter framework to improve the code quality, to start that I will describe which versions it`s going to be used to do this

Flutter: 3.0.1, Stable version
SonarQube: 8.9.5, Community Edition
Docker Desktop: 4.9.0

Flutter is a framework made by google that compiles and runs with almost every common platform, from mobile to desktop and even embedded devices, so this is gonna be the start point. as the time pass and your app need to fit with specific requirements, with this in mind tests are a great way to understand if your code does what they have designed for, basically, in Flutter we have three types of tests, they are:

Unit test: the first one is used to test the minimal part of your code since you have variables and functions to perform. tip: always try to keep your functions only with a single responsibility, this makes the code clean and testable.
Widget test: as the name describe, this kind of test gives us feedback if the widgets are showing correctly for the user.
Integration test: the last one is used to perform a real interaction with the app with a set of instructions to cover more code, like modules.

Keep moving on, we need to create a new Flutter project with the command: flutter create project_name, where on project_name you can give a name to your project.

When finished you will see something like:

All done!
In order to run your application, type:

  $ cd project_name
  $ flutter run

Your application code is in project_name/lib/main.dart.

just type cd project_name and then code . if you are using visual studio code.

Initially, a project structure comes with a simple counter app and a widget test for the same as you can see below:

lib/main.dart

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;

  void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            const Text(
              'You have pushed the button this many times:',
            ),
            Text(
              '$_counter',
              style: Theme.of(context).textTheme.headline4,
            ),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _incrementCounter,
        tooltip: 'Increment',
        child: const Icon(Icons.add),
      ),
    );
  }
}
```



`test/widget_test.dart`

// This is a basic Flutter widget test.
//
// To perform an interaction with a widget in your test, use the WidgetTester
// utility in the flutter_test package. For example, you can send tap and scroll
// gestures. You can also use WidgetTester to find child widgets in the widget
// tree, read text, and verify that the values of widget properties are correct.

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';

import 'package:project_name/main.dart';

void main() {
testWidgets('Counter increments smoke test', (WidgetTester tester) async {
// Build our app and trigger a frame.
await tester.pumpWidget(const MyApp());

// Verify that our counter starts at 0.
expect(find.text('0'), findsOneWidget);
expect(find.text('1'), findsNothing);

// Tap the '+' icon and trigger a frame.
await tester.tap(find.byIcon(Icons.add));
await tester.pump();

// Verify that our counter has incremented.
expect(find.text('0'), findsNothing);
expect(find.text('1'), findsOneWidget);

});
}




With the project created, in next part we will learn how to download [Docker Desktop](https://docs.docker.com/desktop/mac/install/) according your O.S and then go to [SonarQube website](https://www.sonarqube.org) and download the software. With that in mind, hope you enjoy the first part and can't wait to see you in the next one. 

**[CI with SonarQube and Flutter - Part 2](https://dev.to/matteuus/ci-with-sonarqube-and-flutter-part-2-3gd6)**