Sprint Challenge

Challenge Overview

In this sprint challenge, you'll demonstrate your mastery of advanced testing techniques by implementing a solution that requires mocking, handling static methods, and working with AWS Lambda functions.

You'll need to apply concepts from all four modules to complete the challenge successfully:

Creating and configuring mock objects for unit testing
Verifying interactions between components
Testing code that uses static methods
Implementing effective logging for cloud applications
Writing testable code with proper dependency injection

Challenge Objectives

By completing this challenge, you'll demonstrate your ability to:

Isolate units of code by mocking their dependencies
Verify that code interacts with dependencies as expected
Test exception handling for both expected and unexpected error conditions
Refactor code to improve testability
Apply proper logging techniques to facilitate debugging
Work with AWS Lambda functions and understand their test requirements

You'll be assessed on:

Correct implementation of test cases
Proper use of Mockito features (mocks, stubs, verification)
Code organization and test coverage
Handling of edge cases and exceptions
Proper implementation of logging

Example Approach

The challenge will require you to work with code similar to:

// A class with dependencies that needs testing
public class OrderProcessor {
    private final PaymentService paymentService;
    private final OrderRepository orderRepository;
    private final NotificationService notificationService;
    
    // Constructor with dependencies injected (testable approach)
    public OrderProcessor(PaymentService paymentService, 
                         OrderRepository orderRepository,
                         NotificationService notificationService) {
        this.paymentService = paymentService;
        this.orderRepository = orderRepository;
        this.notificationService = notificationService;
    }
    
    public OrderResult processOrder(Order order) throws PaymentException {
        // Validate the order
        if (order == null || order.getItems().isEmpty()) {
            throw new IllegalArgumentException("Order cannot be empty");
        }
        
        // Process payment
        PaymentResult payment = paymentService.processPayment(order.getPaymentDetails());
        
        if (payment.isSuccessful()) {
            // Save the order
            Order savedOrder = orderRepository.save(order);
            
            // Send notification
            notificationService.sendOrderConfirmation(savedOrder);
            
            return new OrderResult(savedOrder.getId(), "Order processed successfully");
        } else {
            throw new PaymentException("Payment failed: " + payment.getErrorMessage());
        }
    }
}

You'll need to write tests that verify all paths through this code, using mocks for the dependencies.

Challenge Overview

Challenge Objectives

Example Approach

Setup Instructions

Resources