Flutter Testing: Unit, Widget & Integration Tests Guide - Related to testing:, retry, &, implementing, widget

A Guide to Automating AWS Infrastructure Deployment

When it comes to managing infrastructure in the cloud, AWS provides several powerful tools that help automate the creation and management of resources.

One of the most effective ways to handle deployments is through AWS CloudFormation. It allows you to define your infrastructure in a declarative way, making it easy to automate the provisioning of AWS services, including Elastic Beanstalk, serverless applications, EC2 instances, security groups, load balancers, and more.

In this guide, we'll explore how to use AWS CloudFormation to deploy infrastructure programmatically. We'll also cover how to manually deploy resources via the AWS Management Console and how to integrate services like Elastic Beanstalk, serverless functions, EC2, IAM, and other AWS resources into your automated workflow.

Using AWS CloudFormation for Infrastructure as Code.

AWS CloudFormation allows you to define your infrastructure using code. CloudFormation provides a unified framework to automate and version your infrastructure by setting up Elastic Beanstalk, EC2 instances, VPCs, IAM roles, Lambda functions, or serverless applications.

CloudFormation templates are written in YAML or JSON format, and they define the resources you need to provision. With CloudFormation, you can automate everything from simple applications to complex, multi-service environments.

Declarative configuration . Describe the desired state of your infrastructure, and CloudFormation ensures that the current state matches it.

. Describe the desired state of your infrastructure, and CloudFormation ensures that the current state matches it. Resource management . Automatically provisions and manages AWS resources such as EC2 instances, RDS databases, VPCs, Lambda functions, IAM roles, and more.

. Automatically provisions and manages AWS resources such as EC2 instances, RDS databases, VPCs, Lambda functions, IAM roles, and more. Declarative stack updates. If you need to modify your infrastructure, simply modification the CloudFormation template, and it will adjust your resources to the new desired state.

Steps to Use CloudFormation for Various AWS Deployments.

Elastic Beanstalk Deployment With CloudFormation.

Create a YAML or JSON CloudFormation template to define your Elastic Beanstalk application and environment. This template can include resources like EC2 instances, security groups, scaling policies, and even the Elastic Beanstalk application itself.

Example of CloudFormation Template (Elastic Beanstalk):

YAML yaml Resources: MyElasticBeanstalkApplication: Type: 'AWS::ElasticBeanstalk::Application' Properties: ApplicationName: "my-application" Description: "Elastic Beanstalk Application for my React and Spring Boot app" MyElasticBeanstalkEnvironment: Type: 'AWS::ElasticBeanstalk::Environment' Properties: EnvironmentName: "my-app-env" ApplicationName: !Ref MyElasticBeanstalkApplication SolutionStackName: "64bit Amazon Linux 2 [website] running Docker" OptionSettings: - Namespace: "aws:autoscaling:asg" OptionName: "MaxSize" Value: "3" - Namespace: "aws:autoscaling:asg" OptionName: "MinSize" Value: "2" - Namespace: "aws:ec2:vpc" OptionName: "VPCId" Value: "vpc-xxxxxxx" - Namespace: "aws:ec2:vpc" OptionName: "Subnets" Value: "subnet-xxxxxxx,subnet-yyyyyyy"

Use the AWS CLI or AWS Management Console to deploy the CloudFormation stack. Once deployed, CloudFormation will automatically create all the resources defined in the template.

YAML bash aws cloudformation create-stack --stack-name MyElasticBeanstalkStack --template-body file://[website].

Serverless Deployment With AWS Lambda, API Gateway, and DynamoDB.

CloudFormation is also great for deploying serverless applications. With services like AWS Lambda, API Gateway, DynamoDB, and S3, you can easily manage serverless workloads.

1. Create a Serverless CloudFormation Template.

This template will include a Lambda function, an API Gateway for accessing the function, and a DynamoDB table.

Example of CloudFormation Template (Serverless):

YAML yaml Resources: MyLambdaFunction: Type: 'AWS::Lambda::Function' Properties: FunctionName: "MyServerlessFunction" Handler: "index.handler" Role: arn:aws:iam::123456789012:role/lambda-execution-role Code: S3Bucket: "my-serverless-code-bucket" S3Key: "[website]" Runtime: [website] MyAPIGateway: Type: 'AWS::ApiGateway::RestApi' Properties: Name: "MyAPI" Description: "API Gateway for My Serverless Application" MyDynamoDBTable: Type: 'AWS::DynamoDB::Table' Properties: TableName: "MyTable" AttributeDefinitions: - AttributeName: "id" AttributeType: "S" KeySchema: - AttributeName: "id" KeyType: "HASH" ProvisionedThroughput: ReadCapacityUnits: 5 WriteCapacityUnits: 5.

Deploy your serverless application using the AWS CLI or AWS Management Console.

YAML bash aws cloudformation create-stack --stack-name MyServerlessStack --template-body file://[website].

CloudFormation can automate the creation of a Virtual Private Cloud (VPC), subnets, security groups, and EC2 instances for more traditional workloads.

1. CloudFormation Template for VPC and EC2.

This template defines a simple EC2 instance within a VPC, with a security group allowing HTTP traffic.

Example of CloudFormation Template (VPC and EC2):

YAML Resources: MyVPC: Type: 'AWS::EC2::VPC' Properties: CidrBlock: "[website]" EnableDnsSupport: "true" EnableDnsHostnames: "true" MySecurityGroup: Type: 'AWS::EC2::SecurityGroup' Properties: GroupDescription: "Allow HTTP and SSH traffic" SecurityGroupIngress: - IpProtocol: "tcp" FromPort: "80" ToPort: "80" CidrIp: "[website]" - IpProtocol: "tcp" FromPort: "22" ToPort: "22" CidrIp: "[website]" MyEC2Instance: Type: 'AWS::EC2::Instance' Properties: InstanceType: "[website]" ImageId: "ami-xxxxxxxx" SecurityGroupIds: - !Ref MySecurityGroup SubnetId: !Ref MyVPC.

YAML aws cloudformation create-stack --stack-name MyEC2Stack --template-body file://[website].

AWS CloudFormation offers more than just simple resource provisioning. Here are some of the advanced elements that make CloudFormation a powerful tool for infrastructure automation:

Stack Sets . Create and manage stacks across multiple AWS accounts and regions, allowing for consistent deployment of infrastructure across your organization.

. Create and manage stacks across multiple AWS accounts and regions, allowing for consistent deployment of infrastructure across your organization. Change Sets . Before applying changes to your CloudFormation stack, preview the changes with a change set to ensure the desired outcome.

. Before applying changes to your CloudFormation stack, preview the changes with a change set to ensure the desired outcome. Outputs . Output values from CloudFormation that you can use for other stacks or applications. For example, output the URL of an API Gateway or the IP address of an EC2 instance.

. Output values from CloudFormation that you can use for other stacks or applications. For example, output the URL of an API Gateway or the IP address of an EC2 instance. Parameters . Pass in parameters to customize your stack without modifying the template itself, making it reusable in different environments.

. Pass in parameters to customize your stack without modifying the template itself, making it reusable in different environments. Mappings. Create key-value pairs for mapping configuration values, like AWS region-specific values, instance types, or other environment-specific parameters.

Using CloudFormation With AWS Services Beyond Elastic Beanstalk.

CloudFormation isn't just limited to Elastic Beanstalk deployments — it's a flexible tool that can be used with a variety of AWS services, including:

AWS Lambda . Automate the deployment of serverless functions along with triggers like API Gateway, S3, or DynamoDB events.

. Automate the deployment of serverless functions along with triggers like API Gateway, S3, or DynamoDB events. Amazon S3 . Use CloudFormation to create S3 buckets and manage their configuration.

. Use CloudFormation to create S3 buckets and manage their configuration. AWS IAM . Automate IAM role and policy creation to control access to your resources.

. Automate IAM role and policy creation to control access to your resources. Amazon RDS . Define RDS databases (MySQL, PostgreSQL, etc.) with all associated configurations like VPC settings, subnets, and security groups.

. Define RDS databases (MySQL, PostgreSQL, etc.) with all associated configurations like VPC settings, subnets, and security groups. Amazon SQS, SNS . Manage queues and topics for your application architecture using CloudFormation.

. Manage queues and topics for your application architecture using CloudFormation. Amazon ECS and EKS. Automate the creation and deployment of containerized applications with services like ECS and EKS.

Manually Deploying Infrastructure from the AWS Management Console.

While CloudFormation automates the process, sometimes manual intervention is necessary. The AWS Management Console allows you to deploy resources manually.

2. Serverless Applications (Lambda + API Gateway).

Go to Lambda Console to create and deploy functions.

Use API Gateway Console to create APIs for your Lambda functions.

Manually launch EC2 instances from the EC2 Console and configure them with your chosen instance type, security groups, and key pairs.

AWS CloudFormation provides a consistent and repeatable way to manage infrastructure for Elastic Beanstalk applications, serverless architectures, and EC2-based applications. With its advanced elements like Stack Sets, Change Sets, and Parameters, CloudFormation can scale to meet the needs of complex environments.

For anyone managing large or dynamic AWS environments, CloudFormation is an essential tool for ensuring consistency, security, and automation across all your AWS deployments.

One of the key principles of writing a good data pipeline is ensuring accurate data is loaded into the target table. We have no control over......

Overview of Databases and Their Significance in Data Management.

Databases are structured repositories of information that can be readily accessed, co......

InfoQ is introducing its first hands-on software architecture certification at QCon London 2025 (April 7-11), the international software development c......

Flutter Testing: Unit, Widget & Integration Tests Guide

Flutter has gained immense popularity for its capability to build cross-platform apps from a single codebase. A crucial part of Flutter app development is Flutter testing, which ensures that your application performs as expected. In this blog, we’ll delve into the three primary types of testing in Flutter: Unit testing in Flutter, Widget testing in Flutter, and Integration testing in Flutter, and explore how to write each effectively.

Flutter test automation plays a key role in ensuring smooth development cycles. Testing helps identify bugs early, enhances code maintainability, and improves user experience. By implementing robust Flutter test cases, developers can:

Ensure smoother app performance and reliability.

Flutter offers a rich set of tools and libraries for Flutter test framework integration, making it easier to maintain a high standard of code quality.

Unit tests verify individual functions, methods, or classes in isolation. Example: Testing a simple Cart function.

Integration tests validate the complete app or a large part of it with actual UI interactions. Example: Testing a Login screen.

Unit testing in Flutter verifies individual units of code (typically methods or functions) to ensure they work as expected. It is the smallest form of testing and helps catch bugs early in development.

Before writing tests, add the Flutter testing dependency to your [website] file:

Then, run flutter pub get to fetch the package.

Let’s assume we have a simple CartItem class:

class CartItem { final String name; final double price; final int quantity; CartItem({required [website], required [website], required this.quantity}); double get total => price * quantity; } class ShoppingCart { final List _items = []; List get items => List.unmodifiable(_items); void addItem(CartItem item) { [website]; } void removeItem(String name) { _items.removeWhere((item) => [website] == name); } double calculateTotal() { return [website], (total, item) => total + [website]; } void clearCart() { [website]; } } Code language: JavaScript (javascript) Enter fullscreen mode Exit fullscreen mode.

To test this class, create a new file [website] under test/:

import 'package:flutter_test/[website]'; import 'package:fluttertest/[website]'; void main() { late ShoppingCart cart; setUp(() { cart = ShoppingCart(); }); test('Add item to cart', () { final item = CartItem(name: 'Laptop', price: [website], quantity: 1); cart.addItem(item); expect([website], 1); expect([website], 'Laptop'); expect([website], [website]; expect([website], 1); }); test('Remove item from cart', () { final item = CartItem(name: 'Laptop', price: [website], quantity: 1); cart.addItem(item); cart.removeItem('Laptop'); expect([website], true); }); test('Calculate total price of items in cart', () { final item1 = CartItem(name: 'Laptop', price: [website], quantity: 1); final item2 = CartItem(name: 'Phone', price: [website], quantity: 2); cart.addItem(item1); cart.addItem(item2); expect(cart.calculateTotal(), [website]; }); test('Clear cart', () { final item1 = CartItem(name: 'Laptop', price: [website], quantity: 1); final item2 = CartItem(name: 'Phone', price: [website], quantity: 2); cart.addItem(item1); cart.addItem(item2); cart.clearCart(); expect([website], true); }); } Enter fullscreen mode Exit fullscreen mode.

Defines a Flutter test case. expect(): Compares actual output with expected output.

_Purpose: _This test ensures that the addItem() method functions correctly and that the cart is updated when a new item is added.

Create a CartItem named “Laptop” with a price of [website] and quantity of 1.

named “Laptop” with a price of [website] and quantity of 1. Call cart.addItem(item) to add the item to the shopping cart.

to add the item to the shopping cart. Use expect() to assert that the cart:

The first item in the cart has the name “Laptop”.

The price of the first item is [website].

Purpose: This test ensures that the removeItem() method removes the correct item from the cart.

Create a CartItem named “Laptop” and add it to the cart.

named “Laptop” and add it to the cart. Call cart.removeItem('Laptop') to remove the item.

to remove the item. Use expect() to assert that the cart is empty ( [website] is true), confirming the item was successfully removed.

Test 3 – Calculate Total Price of Items in Cart.

Purpose: This test checks if the calculateTotal() method correctly calculates the total price for all items in the cart.

Create two items: “Laptop” (price [website], quantity 1) and “Phone” (price [website], quantity 2).

Add both items to the cart using cart.addItem() .

. Call cart.calculateTotal() to get the total price.

to get the total price. Use expect() to assert that the total price is [website] (since 1000 + 500*2 = 2000).

Purpose: This test ensures that the clearCart() method successfully removes all items from the cart.

Create two items: “Laptop” and “Phone”, and add them to the cart.

Call cart.clearCart() to remove all items.

to remove all items. Use expect() to assert that the cart is empty ( [website] is true).

By testing each of these functions, we ensure that the cart behaves as expected, handling typical use cases like adding, removing, and totaling items, as well as clearing the cart. Unit tests like these help catch potential issues early, ensuring robust and reliable business logic.

These tests are significant for any real-world application, especially e-commerce apps where accuracy in cart operations directly impacts user experience and functionality.

Flutter widget testing is used to test individual UI components (widgets) in isolation, ensuring they behave as expected. These tests are one level above unit testing in Flutter and focus on interactions, rendering, and layout of the widget tree without requiring a full app running environment or external services.

Let’s take an example of a contact screen:

import 'package:flutter/[website]'; void main() { runApp(const MyApp()); } class ContactScreen extends StatelessWidget { const MyApp({[website]}); @override Widget build(BuildContext context) { return const MaterialApp( home: ContactForm(), ); } } class ContactForm extends StatefulWidget { const ContactForm({[website]}); @override _ContactFormState createState() => _ContactFormState(); } class _ContactFormState extends State { final _nameController = TextEditingController(); final _emailController = TextEditingController(); final _messageController = TextEditingController(); void _submitForm() { // Simply show a snackbar upon submission [website] .showSnackBar(const SnackBar(content: Text('Form Submitted'))); } @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar(title: const Text('Contact Form')), body: Padding( padding: const [website], child: Column( crossAxisAlignment: [website], children: [ TextField( controller: _nameController, decoration: const InputDecoration(labelText: 'Name'), ), TextField( controller: _emailController, decoration: const InputDecoration(labelText: 'Email'), keyboardType: TextInputType.emailAddress, ), TextField( controller: _messageController, decoration: const InputDecoration(labelText: 'Message'), maxLines: 3, ), const SizedBox(height: 20), ElevatedButton( onPressed: _submitForm, child: const Text('Submit'), ), ], ), ), ); } } Enter fullscreen mode Exit fullscreen mode.

Create a [website] in your test/ directory.

import 'package:flutter/[website]'; import 'package:flutter_test/[website]'; import 'package:fluttertest/[website]'; void main() { testWidgets('Contact Form UI - Submit button test', (WidgetTester tester) async { // Build the ContactForm widget await tester.pumpWidget(const MaterialApp(home: ContactForm())); // Find the text fields and submit button final nameField = [website]; final emailField = [website]; final messageField = [website]; final submitButton = [website]'Submit'); // Verify if the text fields are present expect(nameField, findsOneWidget); expect(emailField, findsOneWidget); expect(messageField, findsOneWidget); // Verify if the submit button is present expect(submitButton, findsOneWidget); // Enter text into the fields await tester.enterText(nameField, 'John Doe'); await tester.enterText(emailField, '[website]'); await tester.enterText( messageField, 'Hello! I would like to inquire about...'); // Tap the submit button await [website]; await [website]; }); } Enter fullscreen mode Exit fullscreen mode.

Find Widgets: Use [website] , [website] , or [website] to locate UI elements.

, , or to locate UI elements. Interact with Widgets: Use enterText , tap , etc.

, , etc. Rebuild UI: await [website] simulates a frame being drawn after a state change.

simulates a frame being drawn after a state change. Expectations: Check UI outputs using expect .

Use the following command in your terminal to run the widget test:

This will execute the test cases and provide a findings of the results.

Building the Widget: await tester.pumpWidget(MaterialApp(home: ContactForm())); initializes the ContactForm widget inside a MaterialApp . Finding Widgets:

[website] is used to locate the three TextField widgets (for name, email, and message).

is used to locate the three widgets (for name, email, and message). [website]'Submit') locates the submit button.

locates the submit button. Verifying Widget Presence:

expect(nameField, findsOneWidget) checks if the text fields are rendered on the screen.

expect(submitButton, findsOneWidget) checks if the submit button is rendered.

await tester.enterText(nameField, 'John Doe'); simulates typing into the name field.

Similarly for the email and message fields.

await [website]; simulates a tap on the submit button.

await [website]; triggers a re-render to reflect the updated state after the tap.

Flutter integration testing verifies the entire app’s functionality by testing multiple widgets, screens, and external dependencies working together. These tests simulate real-world usage and are more complex, as they often involve interacting with the real UI, API calls, and databases.

Flutter has a package specifically for integration testing: integration_test . You can also run these tests on an actual device or emulator.

To get started, you need to add the integration_test and flutter_test packages to your [website] file. If you’re working with Firebase or other back-end services, you might also need to include specific dependencies for mocking or interacting with them.

Now let’s write a simple integration test for the above login screen.

Below integration test will cover all the following scenarios:

Successful login: When the correct email and password are entered, the login should be successful.

Failed login due to incorrect credentials: When the wrong email or password is entered, the login should fail.

Empty fields: Ensure that both fields are validated (even though your code does not explicitly validate, we can test that pressing the button with empty fields results in failure).

UI behavior: Check that the UI components are displayed correctly, such as the TextField widgets and ElevatedButton . You can place this test in your integration_test directory.

import 'package:flutter/[website]'; import 'package:flutter_test/[website]'; import 'package:fluttertest/[website]'; import 'package:integration_test/[website]'; void main() { IntegrationTestWidgetsFlutterBinding.ensureInitialized(); group('LoginScreen Integration Test', () { testWidgets('Successful login scenario', (tester) async { // Pump the LoginScreen widget into the widget tree await tester.pumpWidget(MaterialApp(home: LoginScreen())); // Enter correct credentials await tester.enterText( [website] Key('emailField')), '[website]'); await tester.enterText( [website] Key('passwordField')), 'password123'); // Tap the login button await [website] Key('loginButton'))); await tester.pumpAndSettle(); // Verify the "Login Successful" message is shown expect([website]'Login Successful'), findsOneWidget); }); testWidgets('Failed login with incorrect credentials', (tester) async { // Pump the LoginScreen widget into the widget tree await tester.pumpWidget(MaterialApp(home: LoginScreen())); // Enter incorrect credentials await tester.enterText( [website] Key('emailField')), '[website]'); await tester.enterText( [website] Key('passwordField')), 'wrongpassword'); // Tap the login button await [website] Key('loginButton'))); await tester.pumpAndSettle(); // Verify the "Login Failed" message is shown expect([website]'Login Failed'), findsOneWidget); }); testWidgets('Login attempt with empty fields', (tester) async { // Pump the LoginScreen widget into the widget tree await tester.pumpWidget(MaterialApp(home: LoginScreen())); // Leave both fields empty await tester.enterText([website] Key('emailField')), ''); await tester.enterText([website] Key('passwordField')), ''); // Tap the login button await [website] Key('loginButton'))); await tester.pumpAndSettle(); // Verify the "Login Failed" message is shown (since we expect no credentials entered) expect([website]'Login Failed'), findsOneWidget); }); testWidgets('UI elements are present', (tester) async { // Pump the LoginScreen widget into the widget tree await tester.pumpWidget(MaterialApp(home: LoginScreen())); // Verify the email and password fields are present expect([website] Key('emailField')), findsOneWidget); expect([website] Key('passwordField')), findsOneWidget); // Verify the login button is present expect([website] Key('loginButton')), findsOneWidget); }); }); } Enter fullscreen mode Exit fullscreen mode.

The test enters the correct email and password ( [website] and password123 ), taps the login button, and expects the SnackBar message “Login Successful”.

Failed login due to incorrect credentials:

This test enters incorrect credentials ( [website] and wrongpassword ) and expects the “Login Failed” message in the SnackBar .

This test verifies that if the email and password fields are left empty, tapping the login button results in the “Login Failed” message. This assumes the empty field case results in failure, as your code does not have validation for empty fields, but it could be something you’d like to add.

This test checks that the key elements (the email field, password field, and login button) are properly displayed on the screen.

Command – flutter test integration_test/[website].

Flutter automated testing is a vital aspect of building reliable and maintainable Flutter applications. By leveraging unit testing in Flutter, widget testing, and Flutter integration tests, you can ensure that each piece of your app functions as expected and integrates seamlessly with other components. Flutter’s powerful testing tools make it easier than ever to implement a comprehensive testing strategy for your apps.

Microservices architecture has become the poster child of modern software development. It promises scalability, flexibility, and the dre......

Cloud security firm Wiz uncovered unprotected DeepSeek database giving full control over database operations and access to internal data including mil......

A leading FinTech organization found that adding more ephemeral environments didn’t improve quality. The reason? Managing multiple high-fidelity setups int......

Implementing Exponential Backoff With Spring Retry

Hi, engineers! Have you ever been asked to implement a retry algorithm for your Java code? Or maybe you saw something similar in the codebase of your project?

Java public void someActionWithRetries() { int maxRetries = 3; int attempt = 0; while (true) { attempt++; try { [website]"attempt number = " + attempt); performTask(); [website]"Task completed"); break; } catch (Exception e) { [website]"Failure: " + e.getMessage()); if (attempt >= maxRetries) { [website]"Max retries attempt”); throw new RuntimeException("Unable to complete task after " + maxRetries + " attempts", e); } [website]"Retrying"); } } }.

We can see that the code above executes a while loop until a task is successfully performed or the maximum retry attempt is reached. In this scenario, an exception is thrown, and the method execution terminates.

But what if I tell you that this code might be wrapped into one line method with one annotation?

This is the moment Spring Retry enters the room.

Let’s first answer this simple question: When do we need retries?

API integration. Our downstream service might be unavailable for short periods or just throttling, and we want to retry in case of any of these scenarios. DB connection. DB Transaction may fail because of, for instance, replicas switching or just because of a short time peak in db load. We want to implement retries to back up these scenarios as well. Messaging processing. We want to make sure that when we are consuming messages our service will not fail processing messages in case of first error. Our goal is to give a second chance before sending a message to a dead letter queue.

To add Spring Retry to your application, you need to add two dependencies first: Spring Retry and Spring AOP. As of writing this article, the versions below are the latest.

XML [website] spring-retry [website] org.springframework spring-aspects [website].

We also need to enable retries using annotation @EnableRetry . I’m adding this annotation above @SpringBootApplication annotation.

Java @EnableRetry @SpringBootApplication public class RetryApplication { public static void main(String[] args) { [website], args); } }.

Remember the code I started with? Let’s create a new service and put this code into it. Also, let’s add an implementation of the performTask method, which typically throws exceptions.

Java @Service public class RetriableService { public void someActionWithRetries() { int maxRetries = 3; int attempt = 0; while (true) { attempt++; try { [website]"attempt number = " + attempt); performTask(); [website]"Task completed"); break; } catch (Exception e) { [website]"Failure: " + e.getMessage()); if (attempt >= maxRetries) { [website]"Max retries attempt"); throw new RuntimeException("Unable to complete task after " + maxRetries + " attempts", e); } [website]"Retrying"); } } } private static void performTask() throws RuntimeException { double random = [website]; [website]"Random =" + random); if (random < [website] { throw new RuntimeException("Random Exception"); } [website]"Exception was not thrown"); } }.

And let’s add this service execution to our application entry point.

Java @EnableRetry @SpringBootApplication public class RetryApplication { public static void main(String[] args) { ConfigurableApplicationContext ctx = [website], args); RetriableService bean = ctx.getBean([website]; bean.someActionWithRetries(); } }.

Our main goal is to execute performTask without exceptions. We implemented a simple retry strategy using a while loop and manually managing the number of retries and behavior in case of errors.

Additionally, we updated our main method, just to make code executable (you may execute it any way you prefer to, it actually does not matter).

When we run our application, we may see a similar log:

Plain Text attempt number = 1 Random =0.2026321848196292 Failure: Random Exception Retrying attempt number = 2 Random =0.28573469016365216 Failure: Random Exception Retrying attempt number = 3 Random =0.25888484319397653 Failure: Random Exception Max retries attempt Exception in thread "main" [website] Unable to complete task after 3 attempts.

As we can see, we tried the times and threw an exception when all three attempts failed. Our application is working, but just to execute a one-line method, we added a lot of lines of code. And what if we want to cover another method with the same retry mechanism? Do we need to copy-paste our code? We see that even though our solution is a working one, it does not seem to be an optimal one.

Yes, there is. We are going to add Spring Retry to our logic. We’ve already added all necessary dependencies and enabled Retry by adding annotation. Now, let’s make our method retriable using Spring Retry.

We just need to add the following annotation and provide the number of maximum attempts:

In the second step, we need to delete all the useless code, and this is how our service looks now:

Java @Retryable(maxAttempts = 3) public void someActionWithRetries() { performTask(); } private static void performTask() throws RuntimeException { double random = [website]; [website]"Random =" + random); if (random < [website] { throw new RuntimeException("Random Exception"); } [website]"Exception was not thrown"); }.

When we execute our code, we will see the following log line:

Plain Text Random =0.04263677120823861 Random =0.6175610369948504 Random =0.226853770441114 Exception in thread "main" [website] Random Exception.

The code is still trying to perform the task and fails after three unsuccessful attempts. We have already improved our code by adding an aspect to handle retries. But, we also can make our retries more efficient by introducing an exponential backoff strategy.

Imagine you are calling an external API for which you have some quotas. Sometimes, when you reach your quota, this API throws a throttling exception saying your quota has been exceeded and you need to wait some time to be able to make an API call again.

You know that quotas should be reset quite soon, but I don’t know when exactly it will happen. So, you decide to keep making API calls until a successful response is received, but increase the delay for every next call.

Plain Text 1st call - failure Wait 100ms 2nd call - failure Wait 200ms 3rd call - failure Wait 400ms 4th call - success.

You can see how delays between calls are exponentially increasing. This is exactly what the exponential backoff strategy is about -> retying with exponentially increasing delay.

And yes, we can simply implement this strategy using Spring Retry. Let’s extend our code:

Java @Retryable(maxAttempts = 10, backoff = @Backoff(delay = 100, multiplier = [website], maxDelay = 1000)) public void someActionWithRetries() { performTask(); }.

We’ve increased maxAttempts value to 10, and added backoff configuration with the following params:

Delay – delay in milliseconds for the first retry Multiplier – multiplier for 2nd and following retry. In our case, the second retry will happen in 200ms after the 1st retry failed. If the second retry fails, the third will be executed in 400ms, etc. maxDelay – the limit in milliseconds for delays. When your delay reaches the maxDelay value, it is not increasing anymore.

Let’s add one more log line to be able to track milliseconds of the current timestamp in the performTask method and execute our code:

Java private static void performTask() throws RuntimeException { [website]"Current timestamp=" +System.currentTimeMillis()%100000); ........ }.

Plain Text Current timestamp=41935 Random =0.5630325878313412 Current timestamp=42046 Random =0.3049870877017091 Current timestamp=42252 Random =0.6046786246149355 Current timestamp=42658 Random =0.35486866685708773 Current timestamp=43463 Random =0.5374704153455458 Current timestamp=44469 Random =0.922956819951388 Exception was not thrown.

We can see that it took six attempts (five retries) to perform the task without an exception. We can also see that the difference between the first and second execution is about 100 ms, as configured.

The difference between the second and third execution is about 200 ms, confirming that the multiplier of 2 is working as expected.

Pay attention to the delay before the last execution. It is not 1,600 ms, as we might have expected (a multiplier of 2 for the fifth execution), but 1,000 ms because we set that as the upper limit.

We successfully implemented an exponential backoff strategy using Spring Retry. It helped us to get rid of Utils code and make our retry strategy more manageable. We also discussed scenarios when retries are mostly used, and now we are more aware of when to use them.

The functionality I showed in this article is only about 30% of what Spring Retry allows us to do, and we will see more advanced approaches in the next article.

Testing is a critical yet often time-consuming process. Ensuring that every feature, flow, and edge case works as intended can take up significant res......

AI is being used to open fake feature requests in open source repos, . So far, AI-driven issues have been reported in Cur......

Last year, I made it to Stage 5 before getting kicked out. It was disappointing, but here I am, giving it another try. Y......