Flutter Testing: How to Write Unit and Integration Tests

Are you a Flutter developer who wants to create high-quality apps with bugs that are caught and squashed before they make their way to production? Are you tired of manually testing every single feature in your app every time you make a change? Do you want to implement automated tests that will save you time and effort while increasing the quality of your code? If so, then you need to learn about Flutter testing!

In this article, we will review the basics of Flutter testing and discuss how to write both unit and integration tests for your app. We will cover best practices, useful tools that can make testing easier, and common pitfalls to avoid. So put on your testing hat, grab a cup of coffee, and let's dive in!

What is Flutter Testing?

Testing is an essential part of the software development process. It ensures that your code works as intended, and that new changes don't introduce unwanted problems. Flutter testing is all about writing code that automatically tests your app so that you know it works without needing to manually test every feature. You can run your tests every time you make a change, which enables you to catch issues early in the development process.

There are two types of Flutter tests you can write: unit tests and integration tests. Unit tests test individual parts of your app in isolation, while integration tests test how different parts of your app work together.

Writing Unit Tests

Unit tests are the foundation of effective testing. They are fast, reliable, and can pinpoint issues in specific parts of your app. In Flutter, you can write unit tests for any class or function in your app that has predictable inputs and outputs.

Setting Up Your Test Environment

Before you can start writing unit tests, you need to set up your test environment. First, ensure that your dependencies are up-to-date by running flutter pub get in your terminal. Next, create a new file called example_test.dart in the test directory of your project.

To execute your tests, you can either run flutter test in your terminal or use your IDE's testing tools. IntelliJ IDEA and Android Studio both have excellent testing features built-in.

Writing Your First Test

Let's start by writing a simple test that verifies that 2 + 2 equals 4. Here's what the test code should look like:

void main() {
  test('two plus two equals four', () {
    expect(2 + 2, equals(4));
  });
}

In this code, we're using the test function from the flutter_test package to define our test. The expect function verifies that 2 + 2 equals 4. If the test fails, it means that something in our code isn't working as expected.

Testing Widgets and Views

Unit testing isn't just for code that isn't related to views. You can test widgets and views as well. To do so, you simply wrap the widget in a MaterialApp widget and run your tests as normal. Here's an example:

void main() {
  testWidgets('test ButtonWidget', (WidgetTester tester) async {
    await tester.pumpWidget(MaterialApp(
      home: ButtonWidget(Colors.red),
    ));

    final finder = find.widgetWithText(RaisedButton, 'Click me!');
    expect(finder, findsOneWidget);

    await tester.tap(finder);
    await tester.pump();

    final colorFinder = find.descendant(
        of: find.byType(RaisedButton),
        matching: find.byType(Container));

    final containerColor = tester.widget<Container>(colorFinder).color;
    expect(containerColor, Colors.red);
  });
}

In this code, we're testing a custom ButtonWidget. We're verifying that the widget contains a raised button with the text 'Click me!', that a tap on the button changes the color of a container within the widget, and that the color change is to the correct color.

Testing Functions and Classes

When you're testing a function or class, you want to make sure that it behaves as expected for different inputs. Let's say we have a function called addNumbers:

int addNumbers(int a, int b) {
  return a + b;
}

We can write unit tests for this function to ensure that it returns the expected result for different input values:

void main() {
  group('addNumbers', () {
    test('adds one and two correctly', () {
      expect(addNumbers(1, 2), equals(3));
    });

    test('adds two and two correctly', () {
      expect(addNumbers(2, 2), equals(4));
    });

    test('throws an exception for null inputs', () {
      expect(() => addNumbers(null, null), throwsException);
    });
  });
}

Here, we're using the group function from flutter_test to group our tests together. We're testing that one plus two equals three, two plus two equals four, and that addNumbers throws an exception for null inputs.

Writing Integration Tests

While unit tests test individual parts of your app, integration tests verify that different parts of your app work well together. In Flutter, you can use integration tests to test how multiple screens interact, how APIs are used throughout your app, and more.

Setting Up Your Test Environment

Before you can write an integration test, you need to set up your test environment. First, create a new file called example_integration_test.dart in the test directory of your project. This file will house your integration tests.

To run your tests, you can either run flutter drive --target=test_driver/app.dart in your terminal or use your IDE's testing tools. IntelliJ IDEA and Android Studio both have excellent testing features built-in.

Writing Your First Test

Let's start by writing a simple integration test that navigates to a screen in our app and verifies that a button exists. Here's what the test code should look like:

void main() {
  group('app test', () {
    FlutterDriver driver;

    setUpAll(() async {
      driver = await FlutterDriver.connect();
    });

    tearDownAll(() async {
      if (driver != null) {
        driver.close();
      }
    });

    test('find button', () async {
      await driver.waitFor(find.byValueKey('login_button'));
    });
  });
}

In this code, we're using the FlutterDriver from the flutter_driver package to connect to our app and run our integration test. We're verifying that a button with a value key of 'login_button' exists on the screen.

Testing APIs and Services

Integration tests can also be used to test external APIs and services. This is where you'll need to use a package like http or dio to make REST API calls within your tests.

Here's an example of how you might test an API call using the http package:

void main() {
  group('http testing group', () {
    HttpServer server;
    HttpClient client;

    setUp(() async {
      client = new HttpClient();
    });

    tearDown(() async {
      client.close(force: true);
    });

    test('testing an HTTP call', () async {
      server = await HttpServer.bind('localhost', 4040);

      server.listen((HttpRequest request) async {
        var response = request.response;
        response.statusCode = HttpStatus.ok;
        response.write('Hello, world!');
        response.close();
        await server.close();
      });

      HttpClientRequest request =
      await client.postUrl(Uri.parse('http://localhost:4040'));
      HttpClientResponse response = await request.close();

      expect(response.statusCode, 200);

      String responseBody = await response.transform(utf8.decoder).join();
      expect(responseBody, 'Hello, world!');
    });
  });
}

In this code, we're setting up a test server and making a POST request to that server to verify that our app can connect to an external API.

Conclusion

Testing is an essential component of creating high-quality Flutter apps. With unit and integration tests, you can ensure that your app functions as expected, and run tests automatically every time you make changes. So, what are you waiting for? Start testing your apps today, and let us know how it's going!

Editor Recommended Sites