Java Unit Test Generator for IntelliJ IDEA

                
package com.squaretest.demo1;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class DealsServiceAdapterTest {

    @Mock
    private DealsServiceClient mockDealsService;
    @Mock
    private MetricsAdapter mockMetricsAdapter;

    private DealsServiceAdapter dealsServiceAdapterUnderTest;

    @BeforeEach
    void setUp() {
        dealsServiceAdapterUnderTest = new DealsServiceAdapter(mockDealsService, mockMetricsAdapter);
    }

    @Test
    void testSafeGetDeals() throws Exception {
        // Setup
        final List<DisplayDeal> expectedResult = List.of(
                new DisplayDeal("id", "productName", new BigDecimal("0.00"), "imageUri"));

        // Configure DealsServiceClient.getDeals(...).
        final DealsServiceResponse dealsServiceResponse = new DealsServiceResponse();
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setImageUrl("imageUri");
        dealsServiceResponse.setActiveDeals(List.of(deal));
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenReturn(dealsServiceResponse);

        // Run the test
        final List<DisplayDeal> result = dealsServiceAdapterUnderTest.safeGetDeals("userId");

        // Verify the results
        assertEquals(expectedResult, result);
    }

    @Test
    void testSafeGetDeals_DealsServiceClientThrowsServiceException() throws Exception {
        // Setup
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenThrow(ServiceException.class);

        // Run the test
        final List<DisplayDeal> result = dealsServiceAdapterUnderTest.safeGetDeals("userId");

        // Verify the results
        assertEquals(Collections.emptyList(), result);
        verify(mockMetricsAdapter).recordServiceException(eq("userId"), any(ServiceException.class));
    }

    @Test
    void testSafeGetDeals_DealsServiceClientThrowsNetworkException() throws Exception {
        // Setup
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenThrow(NetworkException.class);

        // Run the test
        final List<DisplayDeal> result = dealsServiceAdapterUnderTest.safeGetDeals("userId");

        // Verify the results
        assertEquals(Collections.emptyList(), result);
        verify(mockMetricsAdapter).recordNetworkException(eq("userId"), any(NetworkException.class));
    }
}
                
              

              
package com.squaretest.demo20;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class DealsServiceAdapterTest {

    @Mock
    private DealsServiceClient mockDealsService;
    @Mock
    private MetricsAdapter mockMetricsAdapter;

    private DealsServiceAdapter dealsServiceAdapterUnderTest;

    @BeforeEach
    void setUp() {
        dealsServiceAdapterUnderTest = new DealsServiceAdapter(mockDealsService, mockMetricsAdapter);
    }

    @Test
    void testSafeGetDeals() throws Exception {
        // Setup
        final List<DisplayDeal> expectedResult = List.of(
                new DisplayDeal("id", "productName", new BigDecimal("0.00"), "imageUri"));

        // Configure DealsServiceClient.getDeals(...).
        final DealsServiceResponse dealsServiceResponse = new DealsServiceResponse();
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setImageUrl("imageUri");
        dealsServiceResponse.getActiveDeals().addAll(List.of(deal));
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenReturn(dealsServiceResponse);

        // Run the test
        final List<DisplayDeal> result = dealsServiceAdapterUnderTest.safeGetDeals("userId");

        // Verify the results
        assertEquals(expectedResult, result);
    }

    @Test
    void testSafeGetDeals_DealsServiceClientThrowsServiceException() throws Exception {
        // Setup
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenThrow(ServiceException.class);

        // Run the test
        final List<DisplayDeal> result = dealsServiceAdapterUnderTest.safeGetDeals("userId");

        // Verify the results
        assertEquals(Collections.emptyList(), result);
        verify(mockMetricsAdapter).recordServiceException(eq("userId"), any(ServiceException.class));
    }

    @Test
    void testSafeGetDeals_DealsServiceClientThrowsNetworkException() throws Exception {
        // Setup
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenThrow(NetworkException.class);

        // Run the test
        final List<DisplayDeal> result = dealsServiceAdapterUnderTest.safeGetDeals("userId");

        // Verify the results
        assertEquals(Collections.emptyList(), result);
        verify(mockMetricsAdapter).recordNetworkException(eq("userId"), any(NetworkException.class));
    }
}
              
            

                
package com.squaretest.demo8;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.math.BigDecimal;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class DealsServiceAdapterAsyncTest {

    @Mock
    private DealsServiceClient mockDealsService;
    @Mock
    private ExecutorService mockExecutorService;
    @Mock
    private MetricsAdapter mockMetricsAdapter;

    private DealsServiceAdapterAsync dealsServiceAdapterAsyncUnderTest;

    @BeforeEach
    void setUp() {
        dealsServiceAdapterAsyncUnderTest = new DealsServiceAdapterAsync(mockDealsService, mockExecutorService,
                mockMetricsAdapter);
    }

    @Test
    void testGetDeals() throws Exception {
        // Setup
        doAnswer(invocation -> {
            ((Runnable) invocation.getArguments()[0]).run();
            return null;
        }).when(mockExecutorService).execute(any(Runnable.class));

        // Configure DealsServiceClient.getDeals(...).
        final DealsServiceResponse dealsServiceResponse = new DealsServiceResponse();
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setImageUrl("imageUri");
        dealsServiceResponse.setActiveDeals(List.of(deal));
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenReturn(dealsServiceResponse);

        // Run the test
        final CompletableFuture<List<DisplayDeal>> result = dealsServiceAdapterAsyncUnderTest.getDeals("userId");

        // Verify the results
        verify(mockExecutorService).execute(any(Runnable.class));
    }

    @Test
    void testGetDeals_DealsServiceClientThrowsServiceException() throws Exception {
        // Setup
        doAnswer(invocation -> {
            ((Runnable) invocation.getArguments()[0]).run();
            return null;
        }).when(mockExecutorService).execute(any(Runnable.class));
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenThrow(ServiceException.class);

        // Run the test
        final CompletableFuture<List<DisplayDeal>> result = dealsServiceAdapterAsyncUnderTest.getDeals("userId");

        // Verify the results
        verify(mockExecutorService).execute(any(Runnable.class));
        verify(mockMetricsAdapter).recordServiceException(eq("userId"), any(ServiceException.class));
    }

    @Test
    void testGetDeals_DealsServiceClientThrowsNetworkException() throws Exception {
        // Setup
        doAnswer(invocation -> {
            ((Runnable) invocation.getArguments()[0]).run();
            return null;
        }).when(mockExecutorService).execute(any(Runnable.class));
        when(mockDealsService.getDeals(any(GetDealsRequest.class))).thenThrow(NetworkException.class);

        // Run the test
        final CompletableFuture<List<DisplayDeal>> result = dealsServiceAdapterAsyncUnderTest.getDeals("userId");

        // Verify the results
        verify(mockExecutorService).execute(any(Runnable.class));
        verify(mockMetricsAdapter).recordNetworkException(eq("userId"), any(NetworkException.class));
    }
}
                
              

                
package com.squaretest.demo3;

import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.model.S3Object;
import org.apache.commons.io.input.BrokenInputStream;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class PurchaseOrderStoreTest {

    @Mock
    private AmazonS3 mockS3Client;
    @Mock
    private MetricAdapter mockMetricAdapter;

    private PurchaseOrderStore purchaseOrderStoreUnderTest;

    @BeforeEach
    void setUp() {
        purchaseOrderStoreUnderTest = new PurchaseOrderStore(mockS3Client, mockMetricAdapter, "bucketName");
    }

    @Test
    void testGetPurchaseOrder() throws Exception {
        // Setup
        // Configure AmazonS3.getObject(...).
        final S3Object spyS3Object = spy(new S3Object());
        spyS3Object.setBucketName("bucketName");
        spyS3Object.setKey("key");
        spyS3Object.setObjectContent(new ByteArrayInputStream("content".getBytes()));
        when(mockS3Client.getObject("bucketName", "key")).thenReturn(spyS3Object);

        // Run the test
        final PDDocument result = purchaseOrderStoreUnderTest.getPurchaseOrder("orderId");

        // Verify the results
        verify(spyS3Object).close();
        verify(mockMetricAdapter).recordPurchaseOrderDocumentDownloaded("orderId");
    }

    @Test
    void testGetPurchaseOrder_AmazonS3ReturnsNoContent() throws Exception {
        // Setup
        // Configure AmazonS3.getObject(...).
        final S3Object spyS3Object = spy(new S3Object());
        spyS3Object.setBucketName("bucketName");
        spyS3Object.setKey("key");
        spyS3Object.setObjectContent(InputStream.nullInputStream());
        when(mockS3Client.getObject("bucketName", "key")).thenReturn(spyS3Object);

        // Run the test
        final PDDocument result = purchaseOrderStoreUnderTest.getPurchaseOrder("orderId");

        // Verify the results
        verify(spyS3Object).close();
        verify(mockMetricAdapter).recordPurchaseOrderDocumentDownloaded("orderId");
    }

    @Test
    void testGetPurchaseOrder_AmazonS3ReturnsBrokenIo() throws Exception {
        // Setup
        // Configure AmazonS3.getObject(...).
        final S3Object spyS3Object = spy(new S3Object());
        spyS3Object.setBucketName("bucketName");
        spyS3Object.setKey("key");
        spyS3Object.setObjectContent(new BrokenInputStream());
        when(mockS3Client.getObject("bucketName", "key")).thenReturn(spyS3Object);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(spyS3Object).close();
        verify(mockMetricAdapter).recordIOException(eq("orderId"), any(IOException.class));
    }

    @Test
    void testGetPurchaseOrder_AmazonS3ThrowsSdkClientException() {
        // Setup
        when(mockS3Client.getObject("bucketName", "key")).thenThrow(SdkClientException.class);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(mockMetricAdapter).recordClientException(eq("orderId"), any(SdkClientException.class));
    }

    @Test
    void testGetPurchaseOrder_AmazonS3ThrowsAmazonServiceException() {
        // Setup
        when(mockS3Client.getObject("bucketName", "key")).thenThrow(AmazonServiceException.class);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(mockMetricAdapter).recordServiceException(eq("orderId"), any(AmazonServiceException.class));
    }
}
                
              

                
package com.squaretest.demo2;

import org.apache.commons.io.input.BrokenInputStream;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.http.AbortableInputStream;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.*;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class PurchaseOrderStoreTest {

    @Mock
    private S3Client mockS3Client;
    @Mock
    private MetricAdapter mockMetricAdapter;

    private PurchaseOrderStore purchaseOrderStoreUnderTest;

    @BeforeEach
    void setUp() {
        purchaseOrderStoreUnderTest = new PurchaseOrderStore(mockS3Client, mockMetricAdapter, "bucketName");
    }

    @Test
    void testGetPurchaseOrder() throws Exception {
        // Setup
        // Configure S3Client.getObject(...).
        final ResponseInputStream<GetObjectResponse> spyResponseInputStream = spy(
                new ResponseInputStream<>(GetObjectResponse.builder().build(),
                        AbortableInputStream.create(new ByteArrayInputStream("objectContent".getBytes()))));
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenReturn(spyResponseInputStream);

        // Run the test
        final PDDocument result = purchaseOrderStoreUnderTest.getPurchaseOrder("orderId");

        // Verify the results
        verify(spyResponseInputStream).close();
        verify(mockMetricAdapter).recordPurchaseOrderDocumentDownloaded("orderId");
    }

    @Test
    void testGetPurchaseOrder_S3ClientReturnsNoContent() throws Exception {
        // Setup
        // Configure S3Client.getObject(...).
        final ResponseInputStream<GetObjectResponse> spyResponseInputStream = spy(
                new ResponseInputStream<>(GetObjectResponse.builder().build(),
                        AbortableInputStream.create(InputStream.nullInputStream())));
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenReturn(spyResponseInputStream);

        // Run the test
        final PDDocument result = purchaseOrderStoreUnderTest.getPurchaseOrder("orderId");

        // Verify the results
        verify(spyResponseInputStream).close();
        verify(mockMetricAdapter).recordPurchaseOrderDocumentDownloaded("orderId");
    }

    @Test
    void testGetPurchaseOrder_S3ClientReturnsBrokenIo() throws Exception {
        // Setup
        // Configure S3Client.getObject(...).
        final ResponseInputStream<GetObjectResponse> spyResponseInputStream = spy(
                new ResponseInputStream<>(GetObjectResponse.builder().build(),
                        AbortableInputStream.create(new BrokenInputStream())));
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenReturn(spyResponseInputStream);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(spyResponseInputStream).close();
        verify(mockMetricAdapter).recordIOException(eq("orderId"), any(IOException.class));
    }

    @Test
    void testGetPurchaseOrder_S3ClientThrowsNoSuchKeyException() {
        // Setup
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenThrow(NoSuchKeyException.class);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(mockMetricAdapter).recordPurchaseOrderNotFound(eq("orderId"), any(NoSuchKeyException.class));
    }

    @Test
    void testGetPurchaseOrder_S3ClientThrowsInvalidObjectStateException() {
        // Setup
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenThrow(InvalidObjectStateException.class);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(mockMetricAdapter).recordServiceException(eq("orderId"), any(S3Exception.class));
    }

    @Test
    void testGetPurchaseOrder_S3ClientThrowsAwsServiceException() {
        // Setup
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenThrow(AwsServiceException.class);

        // Run the test
        assertThrows(AwsServiceException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
    }

    @Test
    void testGetPurchaseOrder_S3ClientThrowsSdkClientException() {
        // Setup
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenThrow(SdkClientException.class);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(mockMetricAdapter).recordClientException(eq("orderId"), any(SdkClientException.class));
    }

    @Test
    void testGetPurchaseOrder_S3ClientThrowsS3Exception() {
        // Setup
        when(mockS3Client.getObject(GetObjectRequest.builder()
                .bucket("bucketName")
                .key("key")
                .build())).thenThrow(S3Exception.class);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(mockMetricAdapter).recordServiceException(eq("orderId"), any(S3Exception.class));
    }
}
                
              

                
package com.squaretest.demo11;

import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBMapper;
import com.amazonaws.services.dynamodbv2.model.AmazonDynamoDBException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class OrderStoreTest {

    @Mock
    private DynamoDBMapper mockDynamoDBMapper;
    @Mock
    private MetricsAdapter mockMetricsAdapter;

    private OrderStore orderStoreUnderTest;

    @BeforeEach
    void setUp() {
        orderStoreUnderTest = new OrderStore(mockDynamoDBMapper, mockMetricsAdapter);
    }

    @Test
    void testGetOrder() throws Exception {
        // Setup
        // Configure DynamoDBMapper.load(...).
        final Order order = new Order();
        order.setId("id");
        order.setShipAddress("shipAddress");
        order.setShipDate(LocalDateTime.of(2020, 1, 1, 0, 0, 0, 0).toInstant(ZoneOffset.UTC));
        final Product product = new Product();
        product.setId("id");
        order.setProducts(List.of(product));
        when(mockDynamoDBMapper.load(Order.class, "orderId")).thenReturn(order);

        // Run the test
        final Order result = orderStoreUnderTest.getOrder("orderId");

        // Verify the results
        verify(mockMetricsAdapter).recordOrderFound("orderId");
    }

    @Test
    void testGetOrder_DynamoDBMapperReturnsNull() {
        // Setup
        when(mockDynamoDBMapper.load(Order.class, "orderId")).thenReturn(null);

        // Run the test
        assertThrows(OrderNotFoundException.class, () -> orderStoreUnderTest.getOrder("orderId"));
        verify(mockMetricsAdapter).recordOrderNotFound("orderId");
    }

    @Test
    void testGetOrder_DynamoDBMapperThrowsAmazonDynamoDBException() {
        // Setup
        when(mockDynamoDBMapper.load(Order.class, "orderId")).thenThrow(AmazonDynamoDBException.class);

        // Run the test
        assertThrows(OrderStoreException.class, () -> orderStoreUnderTest.getOrder("orderId"));
        verify(mockMetricsAdapter).recordOrderStoreException(eq("orderId"), any(Exception.class));
    }
}
                
              

                
package com.squaretest.demo12;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class OrderStoreTest {

    @Mock
    private DynamoDbTable<Order> mockOrdersTable;
    @Mock
    private MetricsAdapter mockMetricsAdapter;

    private OrderStore orderStoreUnderTest;

    @BeforeEach
    void setUp() {
        orderStoreUnderTest = new OrderStore(mockOrdersTable, mockMetricsAdapter);
    }

    @Test
    void testGetOrder() throws Exception {
        // Setup
        // Configure DynamoDbTable.getItem(...).
        final Order order = new Order();
        order.setId("id");
        order.setShipAddress("shipAddress");
        order.setShipDate(LocalDateTime.of(2020, 1, 1, 0, 0, 0, 0).toInstant(ZoneOffset.UTC));
        final Product product = new Product();
        product.setId("id");
        order.setProducts(List.of(product));
        when(mockOrdersTable.getItem(Key.builder()
                .partitionValue("orderId")
                .build())).thenReturn(order);

        // Run the test
        final Order result = orderStoreUnderTest.getOrder("orderId");

        // Verify the results
        verify(mockMetricsAdapter).recordOrderRetrieved("orderId");
    }

    @Test
    void testGetOrder_DynamoDbTableReturnsNull() {
        // Setup
        when(mockOrdersTable.getItem(Key.builder()
                .partitionValue("orderId")
                .build())).thenReturn(null);

        // Run the test
        assertThrows(OrderStoreException.class, () -> orderStoreUnderTest.getOrder("orderId"));
        verify(mockMetricsAdapter).recordOrderNotFound("orderId");
    }

    @Test
    void testGetOrder_DynamoDbTableThrowsSdkClientException() {
        // Setup
        when(mockOrdersTable.getItem(Key.builder()
                .partitionValue("orderId")
                .build())).thenThrow(SdkClientException.class);

        // Run the test
        assertThrows(OrderStoreException.class, () -> orderStoreUnderTest.getOrder("orderId"));
        verify(mockMetricsAdapter).recordOrderStoreException(any(Exception.class));
    }

    @Test
    void testGetOrder_DynamoDbTableThrowsDynamoDbException() {
        // Setup
        when(mockOrdersTable.getItem(Key.builder()
                .partitionValue("orderId")
                .build())).thenThrow(DynamoDbException.class);

        // Run the test
        assertThrows(OrderStoreException.class, () -> orderStoreUnderTest.getOrder("orderId"));
        verify(mockMetricsAdapter).recordOrderStoreException(any(Exception.class));
    }
}
                
              

                
package com.squaretest.demo18;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.services.comprehend.ComprehendClient;
import software.amazon.awssdk.services.comprehend.model.*;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class LanguageAnalyzerTest {

    @Mock
    private ComprehendClient mockComService;

    private LanguageAnalyzer languageAnalyzerUnderTest;

    @BeforeEach
    void setUp() {
        languageAnalyzerUnderTest = new LanguageAnalyzer(mockComService);
    }

    @Test
    void testGetEntitiesMentioned() throws Exception {
        // Setup
        // Configure ComprehendClient.detectEntities(...).
        final DetectEntitiesResponse detectEntitiesResponse = DetectEntitiesResponse.builder()
                .entities(Entity.builder()
                        .text("text")
                        .build())
                .build();
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenReturn(detectEntitiesResponse);

        // Run the test
        final List<String> result = languageAnalyzerUnderTest.getEntitiesMentioned("text");

        // Verify the results
        assertEquals(List.of("value"), result);
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsInvalidRequestException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(InvalidRequestException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsResourceUnavailableException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(ResourceUnavailableException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsTextSizeLimitExceededException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(TextSizeLimitExceededException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsUnsupportedLanguageException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(UnsupportedLanguageException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsInternalServerException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(InternalServerException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsAwsServiceException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(AwsServiceException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsSdkClientException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(SdkClientException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }

    @Test
    void testGetEntitiesMentioned_ComprehendClientThrowsComprehendException() {
        // Setup
        when(mockComService.detectEntities(DetectEntitiesRequest.builder()
                .text("text")
                .languageCode(LanguageCode.EN)
                .build())).thenThrow(ComprehendException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }
}
                
              

                
package com.squaretest.demo16;

import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageException;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class PurchaseOrderStoreTest {

    @Mock
    private Storage mockStorage;
    @Mock
    private MetricAdapter mockMetricAdapter;

    private PurchaseOrderStore purchaseOrderStoreUnderTest;

    @BeforeEach
    void setUp() {
        purchaseOrderStoreUnderTest = new PurchaseOrderStore(mockStorage, mockMetricAdapter, "bucketName");
    }

    @Test
    void testGetPurchaseOrder() throws Exception {
        // Setup
        when(mockStorage.readAllBytes("bucketName", "blob")).thenReturn("content".getBytes());

        // Run the test
        final PDDocument result = purchaseOrderStoreUnderTest.getPurchaseOrder("orderId");

        // Verify the results
        verify(mockMetricAdapter).recordPurchaseOrderRetrieved("orderId");
    }

    @Test
    void testGetPurchaseOrder_StorageThrowsStorageException() {
        // Setup
        when(mockStorage.readAllBytes("bucketName", "blob")).thenThrow(StorageException.class);

        // Run the test
        assertThrows(PurchaseOrderStoreException.class, () -> purchaseOrderStoreUnderTest.getPurchaseOrder("orderId"));
        verify(mockMetricAdapter).recordStorageException("orderId",
                  new StorageException(0, "message", "reason", new Exception("message")));
    }
}
                
              

                
package com.squaretest.demo17;

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.language.v1.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class LanguageAnalyzerTest {

    @Mock
    private LanguageServiceClient mockLanguageService;

    private LanguageAnalyzer languageAnalyzerUnderTest;

    @BeforeEach
    void setUp() {
        languageAnalyzerUnderTest = new LanguageAnalyzer(mockLanguageService);
    }

    @Test
    void testGetEntitiesMentioned() throws Exception {
        // Setup
        // Configure LanguageServiceClient.analyzeEntities(...).
        final AnalyzeEntitiesResponse analyzeEntitiesResponse = AnalyzeEntitiesResponse.newBuilder()
                .addEntities(Entity.newBuilder()
                        .setName("name")
                        .build())
                .build();
        when(mockLanguageService.analyzeEntities(AnalyzeEntitiesRequest.newBuilder()
                .setDocument(Document.newBuilder()
                        .setType(Document.Type.PLAIN_TEXT)
                        .setContent("value")
                        .build())
                .setEncodingType(EncodingType.UTF16)
                .build())).thenReturn(analyzeEntitiesResponse);

        // Run the test
        final List<String> result = languageAnalyzerUnderTest.getEntitiesMentioned("text");

        // Verify the results
        assertEquals(List.of("value"), result);
    }

    @Test
    void testGetEntitiesMentioned_LanguageServiceClientThrowsApiException() {
        // Setup
        when(mockLanguageService.analyzeEntities(AnalyzeEntitiesRequest.newBuilder()
                .setDocument(Document.newBuilder()
                        .setType(Document.Type.PLAIN_TEXT)
                        .setContent("value")
                        .build())
                .setEncodingType(EncodingType.UTF16)
                .build())).thenThrow(ApiException.class);

        // Run the test
        assertThrows(LanguageServiceException.class, () -> languageAnalyzerUnderTest.getEntitiesMentioned("text"));
    }
}
                
              

                
package com.squaretest.demo4;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;

@ExtendWith(SpringExtension.class)
@WebMvcTest(DealsController.class)
class DealsControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private DealsProvider mockDealsProvider;
    @MockBean
    private MetricAdapter mockMetricAdapter;

    @Test
    void testGetCurrentDeals() throws Exception {
        // Setup
        // Configure DealsProvider.getCurrentDeals(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        final List<Deal> deals = List.of(deal);
        when(mockDealsProvider.getCurrentDeals("sortKey")).thenReturn(deals);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/deals/current")
                        .param("sortKey", "sortKey")
                        .accept(MediaType.APPLICATION_JSON))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
        verify(mockMetricAdapter).recordDealsRetrieved("sortKey");
    }

    @Test
    void testGetCurrentDeals_DealsProviderReturnsNoItems() throws Exception {
        // Setup
        when(mockDealsProvider.getCurrentDeals("sortKey")).thenReturn(Collections.emptyList());

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/deals/current")
                        .param("sortKey", "sortKey")
                        .accept(MediaType.APPLICATION_JSON))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("[]");
        verify(mockMetricAdapter).recordDealsRetrieved("sortKey");
    }

    @Test
    void testGetCurrentDeals_DealsProviderThrowsNetworkException() throws Exception {
        // Setup
        when(mockDealsProvider.getCurrentDeals("sortKey")).thenThrow(NetworkException.class);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/deals/current")
                        .param("sortKey", "sortKey")
                        .accept(MediaType.APPLICATION_JSON))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("[]");
        verify(mockMetricAdapter).recordNetworkException(eq("sortKey"), any(NetworkException.class));
    }

    @Test
    void testGetCurrentDeals_DealsProviderThrowsServiceException() throws Exception {
        // Setup
        when(mockDealsProvider.getCurrentDeals("sortKey")).thenThrow(ServiceException.class);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/deals/current")
                        .param("sortKey", "sortKey")
                        .accept(MediaType.APPLICATION_JSON))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("[]");
        verify(mockMetricAdapter).recordServiceException(eq("sortKey"), any(ServiceException.class));
    }
}
                
              

                
package com.squaretest.demo5;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;

@ExtendWith(SpringExtension.class)
@WebMvcTest(DealsController.class)
class DealsControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private DealsStore mockDealsStore;

    @Test
    void testList() throws Exception {
        // Setup
        // Configure DealsStore.getCurrentDeals(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        final List<Deal> deals = List.of(deal);
        when(mockDealsStore.getCurrentDeals()).thenReturn(deals);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/admin/deals")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
    }

    @Test
    void testList_DealsStoreReturnsNoItems() throws Exception {
        // Setup
        when(mockDealsStore.getCurrentDeals()).thenReturn(Collections.emptyList());

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/admin/deals")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
    }

    @Test
    void testList_DealsStoreThrowsNetworkException() throws Exception {
        // Setup
        when(mockDealsStore.getCurrentDeals()).thenThrow(NetworkException.class);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/admin/deals")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
    }

    @Test
    void testList_DealsStoreThrowsServiceException() throws Exception {
        // Setup
        when(mockDealsStore.getCurrentDeals()).thenThrow(ServiceException.class);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/admin/deals")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
    }

    @Test
    void testNewDeal() throws Exception {
        // Setup
        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/admin/deals/new")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
    }

    @Test
    void testCreateNewDeal() throws Exception {
        // Setup
        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(post("/admin/deals/new")
                        .param("id", "id")
                        .param("productName", "productName")
                        .param("price", "0")
                        .param("quantityRemaining", "0")
                        .param("imageUrl", "imageUrl")
                        .with(csrf())
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");

        // Confirm DealsStore.save(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        verify(mockDealsStore).save(deal);
    }

    @Test
    void testCreateNewDeal_DealsStoreThrowsNetworkException() throws Exception {
        // Setup
        // Configure DealsStore.save(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        doThrow(NetworkException.class).when(mockDealsStore).save(deal);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(post("/admin/deals/new")
                        .param("id", "id")
                        .param("productName", "productName")
                        .param("price", "0")
                        .param("quantityRemaining", "0")
                        .param("imageUrl", "imageUrl")
                        .with(csrf())
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
    }

    @Test
    void testCreateNewDeal_DealsStoreThrowsServiceException() throws Exception {
        // Setup
        // Configure DealsStore.save(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        doThrow(ServiceException.class).when(mockDealsStore).save(deal);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(post("/admin/deals/new")
                        .param("id", "id")
                        .param("productName", "productName")
                        .param("price", "0")
                        .param("quantityRemaining", "0")
                        .param("imageUrl", "imageUrl")
                        .with(csrf())
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
    }
}
                
              

                
package com.squaretest.demo10;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;

@ExtendWith(SpringExtension.class)
@WebMvcTest(IndexController.class)
class IndexControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private DealsServiceAsync mockDealsService;
    @MockBean
    private OrdersServiceAsync mockOrdersService;
    @MockBean
    private MetricAdapter mockMetricAdapter;

    @Test
    void testIndex() throws Exception {
        // Setup
        // Configure DealsServiceAsync.getDeals(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        final CompletableFuture<List<Deal>> listCompletableFuture = CompletableFuture.completedFuture(List.of(deal));
        when(mockDealsService.getDeals()).thenReturn(listCompletableFuture);

        // Configure OrdersServiceAsync.getRecentOrders(...).
        final Order order = new Order();
        order.setId("id");
        order.setShipAddress("shipAddress");
        order.setShipDate(LocalDateTime.of(2020, 1, 1, 0, 0, 0, 0).toInstant(ZoneOffset.UTC));
        final Product product = new Product();
        product.setId("id");
        order.setProducts(List.of(product));
        final CompletableFuture<List<Order>> listCompletableFuture1 = CompletableFuture.completedFuture(List.of(order));
        when(mockOrdersService.getRecentOrders("customerId")).thenReturn(listCompletableFuture1);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
        verify(mockMetricAdapter).recordGetDealsCallSuccess();
        verify(mockMetricAdapter).recordGetRecentOrdersCallSuccess();
    }

    @Test
    void testIndex_DealsServiceAsyncReturnsNoItems() throws Exception {
        // Setup
        // Configure DealsServiceAsync.getDeals(...).
        final CompletableFuture<List<Deal>> listCompletableFuture = CompletableFuture.completedFuture(
                Collections.emptyList());
        when(mockDealsService.getDeals()).thenReturn(listCompletableFuture);

        // Configure OrdersServiceAsync.getRecentOrders(...).
        final Order order = new Order();
        order.setId("id");
        order.setShipAddress("shipAddress");
        order.setShipDate(LocalDateTime.of(2020, 1, 1, 0, 0, 0, 0).toInstant(ZoneOffset.UTC));
        final Product product = new Product();
        product.setId("id");
        order.setProducts(List.of(product));
        final CompletableFuture<List<Order>> listCompletableFuture1 = CompletableFuture.completedFuture(List.of(order));
        when(mockOrdersService.getRecentOrders("customerId")).thenReturn(listCompletableFuture1);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
        verify(mockMetricAdapter).recordGetDealsCallSuccess();
        verify(mockMetricAdapter).recordGetRecentOrdersCallSuccess();
    }

    @Test
    void testIndex_DealsServiceAsyncReturnsFailure() throws Exception {
        // Setup
        // Configure DealsServiceAsync.getDeals(...).
        final CompletableFuture<List<Deal>> listCompletableFuture = CompletableFuture.failedFuture(
                new Exception("message"));
        when(mockDealsService.getDeals()).thenReturn(listCompletableFuture);

        // Configure OrdersServiceAsync.getRecentOrders(...).
        final Order order = new Order();
        order.setId("id");
        order.setShipAddress("shipAddress");
        order.setShipDate(LocalDateTime.of(2020, 1, 1, 0, 0, 0, 0).toInstant(ZoneOffset.UTC));
        final Product product = new Product();
        product.setId("id");
        order.setProducts(List.of(product));
        final CompletableFuture<List<Order>> listCompletableFuture1 = CompletableFuture.completedFuture(List.of(order));
        when(mockOrdersService.getRecentOrders("customerId")).thenReturn(listCompletableFuture1);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
        verify(mockMetricAdapter).recordGetDealsException(any(Exception.class));
        verify(mockMetricAdapter).recordGetRecentOrdersCallSuccess();
    }

    @Test
    void testIndex_OrdersServiceAsyncReturnsNoItems() throws Exception {
        // Setup
        // Configure DealsServiceAsync.getDeals(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        final CompletableFuture<List<Deal>> listCompletableFuture = CompletableFuture.completedFuture(List.of(deal));
        when(mockDealsService.getDeals()).thenReturn(listCompletableFuture);

        // Configure OrdersServiceAsync.getRecentOrders(...).
        final CompletableFuture<List<Order>> listCompletableFuture1 = CompletableFuture.completedFuture(
                Collections.emptyList());
        when(mockOrdersService.getRecentOrders("customerId")).thenReturn(listCompletableFuture1);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
        verify(mockMetricAdapter).recordGetDealsCallSuccess();
        verify(mockMetricAdapter).recordGetRecentOrdersCallSuccess();
    }

    @Test
    void testIndex_OrdersServiceAsyncReturnsFailure() throws Exception {
        // Setup
        // Configure DealsServiceAsync.getDeals(...).
        final Deal deal = new Deal();
        deal.setId("id");
        deal.setProductName("productName");
        deal.setPrice(new BigDecimal("0.00"));
        deal.setQuantityRemaining(0);
        deal.setImageUrl("imageUrl");
        final CompletableFuture<List<Deal>> listCompletableFuture = CompletableFuture.completedFuture(List.of(deal));
        when(mockDealsService.getDeals()).thenReturn(listCompletableFuture);

        // Configure OrdersServiceAsync.getRecentOrders(...).
        final CompletableFuture<List<Order>> listCompletableFuture1 = CompletableFuture.failedFuture(
                new Exception("message"));
        when(mockOrdersService.getRecentOrders("customerId")).thenReturn(listCompletableFuture1);

        // Run the test
        final MockHttpServletResponse response = mockMvc.perform(get("/")
                        .accept(MediaType.TEXT_HTML))
                .andReturn().getResponse();

        // Verify the results
        assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
        assertThat(response.getContentAsString()).isEqualTo("expectedResponse");
        verify(mockMetricAdapter).recordGetDealsCallSuccess();
        verify(mockMetricAdapter).recordGetRecentOrdersException(any(Exception.class));
    }
}
                
              

                
package com.squaretest.demo6;

import org.junit.jupiter.api.Test;

import java.util.regex.PatternSyntaxException;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

class StringUtilsTest {

    @Test
    void testReplaceFirst() {
        assertEquals("text", StringUtils.replaceFirst("text", "regex", "replacement"));
        assertThrows(PatternSyntaxException.class, () -> StringUtils.replaceFirst("text", "regex", "replacement"));
    }
}
                
              

                
package com.squaretest.demo7;

import org.junit.jupiter.api.Test;

import java.util.Map;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

class UriTest {

    @Test
    void testParse() throws Exception {
        // Run the test
        final Uri result = Uri.parse("theUri");
        assertEquals("schema", result.getSchema());
        assertEquals("authority", result.getAuthority());
        assertEquals("path", result.getPath());
        assertEquals(Map.ofEntries(Map.entry("value", "value")), result.getQueryParams());
    }

    @Test
    void testParse_ThrowsUriParseException() {
        // Setup
        // Run the test
        assertThrows(UriParseException.class, () -> Uri.parse("theUri"));
    }
}
                
              

                
package com.squaretest.demo19;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

class JavaVersionTest {

    @Test
    void testAtLeast() {
        assertFalse(JavaVersion.JAVA_0_9.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_1.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_2.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_3.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_4.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_5.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_6.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_7.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_8.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_9.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_9.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_10.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_11.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_12.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_13.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_14.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_15.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_16.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_17.atLeast(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_RECENT.atLeast(JavaVersion.JAVA_0_9));
    }

    @Test
    void testAtMost() {
        assertFalse(JavaVersion.JAVA_0_9.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_1.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_2.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_3.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_4.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_5.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_6.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_7.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_8.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_1_9.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_9.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_10.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_11.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_12.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_13.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_14.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_15.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_16.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_17.atMost(JavaVersion.JAVA_0_9));
        assertFalse(JavaVersion.JAVA_RECENT.atMost(JavaVersion.JAVA_0_9));
    }

    @Test
    void testGetJavaVersion() {
        assertEquals(JavaVersion.JAVA_0_9, JavaVersion.getJavaVersion("nom"));
    }

    @Test
    void testGet() {
        assertEquals(JavaVersion.JAVA_0_9, JavaVersion.get("versionStr"));
    }

    @Test
    void testToString() {
        assertEquals("name", JavaVersion.JAVA_0_9.toString());
        assertEquals("name", JavaVersion.JAVA_1_1.toString());
        assertEquals("name", JavaVersion.JAVA_1_2.toString());
        assertEquals("name", JavaVersion.JAVA_1_3.toString());
        assertEquals("name", JavaVersion.JAVA_1_4.toString());
        assertEquals("name", JavaVersion.JAVA_1_5.toString());
        assertEquals("name", JavaVersion.JAVA_1_6.toString());
        assertEquals("name", JavaVersion.JAVA_1_7.toString());
        assertEquals("name", JavaVersion.JAVA_1_8.toString());
        assertEquals("name", JavaVersion.JAVA_1_9.toString());
        assertEquals("name", JavaVersion.JAVA_9.toString());
        assertEquals("name", JavaVersion.JAVA_10.toString());
        assertEquals("name", JavaVersion.JAVA_11.toString());
        assertEquals("name", JavaVersion.JAVA_12.toString());
        assertEquals("name", JavaVersion.JAVA_13.toString());
        assertEquals("name", JavaVersion.JAVA_14.toString());
        assertEquals("name", JavaVersion.JAVA_15.toString());
        assertEquals("name", JavaVersion.JAVA_16.toString());
        assertEquals("name", JavaVersion.JAVA_17.toString());
        assertEquals("name", JavaVersion.JAVA_RECENT.toString());
    }
}