Devin/1746846220 add unit tests

common/src/test/java/com/wfsample/common/BeachShirtsUtilsTest.java

@@ -0,0 +1,49 @@
+package com.wfsample.common;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Unit tests for BeachShirtsUtils class.
+ */
+public class BeachShirtsUtilsTest {
+
+    @Test
+    public void testIsErrorRequest() {
+        AtomicInteger index = new AtomicInteger(0);
+
+        assertTrue(BeachShirtsUtils.isErrorRequest(index, 1, 10));
+
+        index = new AtomicInteger(0);
+
+        assertFalse(BeachShirtsUtils.isErrorRequest(index, 0, 2)); // First request (index=1)
+        assertTrue(BeachShirtsUtils.isErrorRequest(index, 0, 2));  // Second request (index=2)
+        assertFalse(BeachShirtsUtils.isErrorRequest(index, 0, 2)); // Third request (index=3)
+    }
+
+    @Test
+    public void testGetRequestLatency() {
+        Random rand = new Random(123); // Use fixed seed for reproducibility
+
+        long mean = 100;
+        long delta = 0;
+        assertEquals(mean, BeachShirtsUtils.getRequestLatency(mean, delta, rand));
+
+        mean = -100;
+        delta = 0;
+        assertEquals(mean, BeachShirtsUtils.getRequestLatency(mean, delta, rand));
+
+        mean = 0;
+        delta = 0;
+        assertEquals(0, BeachShirtsUtils.getRequestLatency(mean, delta, rand));
+
+        mean = 100;
+        delta = 50;
+        long result = BeachShirtsUtils.getRequestLatency(mean, delta, rand);
+        assertTrue("Result should be within reasonable range of mean", 
+                  result >= mean - 2*delta && result <= mean + 2*delta);
+    }
+}

common/src/test/java/com/wfsample/common/dto/OrderDTOTest.java

@@ -0,0 +1,47 @@
+package com.wfsample.common.dto;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ * Unit tests for OrderDTO class.
+ */
+public class OrderDTOTest {
+
+    @Test
+    public void testOrderDTOSettersAndGetters() {
+        OrderDTO orderDTO = new OrderDTO();
+
+        String styleName = "testStyle";
+        int quantity = 5;
+        orderDTO.setStyleName(styleName);
+        orderDTO.setQuantity(quantity);
+
+        assertEquals(styleName, orderDTO.getStyleName());
+        assertEquals(quantity, orderDTO.getQuantity());
+    }
+
+    @Test
+    public void testOrderDTOUpdateValues() {
+        OrderDTO orderDTO = new OrderDTO();
+
+        orderDTO.setStyleName("initialStyle");
+        orderDTO.setQuantity(1);
+
+        String newStyleName = "updatedStyle";
+        int newQuantity = 10;
+        orderDTO.setStyleName(newStyleName);
+        orderDTO.setQuantity(newQuantity);
+
+        assertEquals(newStyleName, orderDTO.getStyleName());
+        assertEquals(newQuantity, orderDTO.getQuantity());
+    }
+
+    @Test
+    public void testDefaultValues() {
+        OrderDTO orderDTO = new OrderDTO();
+
+        assertNull(orderDTO.getStyleName());
+        assertEquals(0, orderDTO.getQuantity());
+    }
+}

delivery/src/test/java/com/wfsample/delivery/DeliveryControllerTest.java

@@ -0,0 +1,60 @@
+package com.wfsample.delivery;
+
+import com.wavefront.sdk.jersey.WavefrontJerseyFactory;
+import com.wfsample.common.dto.DeliveryStatusDTO;
+import com.wfsample.common.dto.PackedShirtsDTO;
+import com.wfsample.common.dto.ShirtDTO;
+
+import io.opentracing.Tracer;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.core.env.Environment;
+
+import javax.ws.rs.core.Response;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.when;
+
+/**
+ * Unit tests for DeliveryController.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class DeliveryControllerTest {
+
+    @Mock
+    private Environment env;
+
+    @Mock
+    private WavefrontJerseyFactory wavefrontJerseyFactory;
+
+    private DeliveryController deliveryController;
+
+    @Before
+    public void setUp() {
+        when(env.getProperty("request.slow.percentage", Double.class)).thenReturn(0.0);
+        when(env.getProperty("request.slow.latency", Long.class)).thenReturn(0L);
+        when(env.getProperty("request.error.interval", Integer.class)).thenReturn(0);
+
+        deliveryController = new DeliveryController(env, wavefrontJerseyFactory);
+    }
+
+    @Test
+    public void testTrackOrder() {
+        Response response = deliveryController.trackOrder("12345");
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+    }
+
+    @Test
+    public void testCancelOrder() {
+        Response response = deliveryController.cancelOrder("12345");
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+    }
+}

delivery/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

@@ -0,0 +1 @@
+mock-maker-inline

packaging/src/test/java/com/wfsample/packaging/PackagingServiceTest.java

@@ -0,0 +1,181 @@
+package com.wfsample.packaging;
+
+import com.wfsample.beachshirts.GiftPack;
+import com.wfsample.beachshirts.PackagingGrpc;
+import com.wfsample.beachshirts.PackedShirts;
+import com.wfsample.beachshirts.Shirt;
+import com.wfsample.beachshirts.ShirtStyle;
+import com.wfsample.beachshirts.Status;
+import com.wfsample.beachshirts.WrapRequest;
+import com.wfsample.beachshirts.WrappingType;
+import com.wfsample.beachshirts.WrappingTypes;
+import com.wfsample.beachshirts.Void;
+import com.wfsample.common.GrpcServiceConfig;
+
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Unit tests for PackagingService.
+ */
+public class PackagingServiceTest {
+
+    @Rule
+    public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    private PackagingGrpc.PackagingBlockingStub blockingStub;
+
+    @Mock
+    private StreamObserver<WrappingTypes> responseObserver;
+
+    private TestPackagingImpl packagingImpl;
+    private String serverName;
+
+    /**
+     * Test implementation of PackagingGrpc.PackagingImplBase for unit testing.
+     */
+    private static class TestPackagingImpl extends PackagingGrpc.PackagingImplBase {
+        private final Random rand = new Random(0L);
+
+        public TestPackagingImpl(GrpcServiceConfig config) {
+        }
+
+        @Override
+        public void wrapShirts(WrapRequest request, StreamObserver<PackedShirts> responseObserver) {
+            int count = request.getShirtsCount();
+            PackedShirts packedShirts = PackedShirts.newBuilder()
+                .addAllShirts(request.getShirtsList())
+                .build();
+            responseObserver.onNext(packedShirts);
+            responseObserver.onCompleted();
+        }
+
+        @Override
+        public void giftWrap(WrapRequest request, StreamObserver<GiftPack> responseObserver) {
+            GiftPack giftPack = GiftPack.newBuilder()
+                .setGiftMaterial(com.google.protobuf.ByteString.copyFromUtf8("gift material"))
+                .build();
+            responseObserver.onNext(giftPack);
+            responseObserver.onCompleted();
+        }
+
+        @Override
+        public void restockMaterial(WrappingType request, StreamObserver<Status> responseObserver) {
+            responseObserver.onNext(Status.newBuilder().setStatus(true).build());
+            responseObserver.onCompleted();
+        }
+
+        @Override
+        public void getPackingTypes(Void request, StreamObserver<WrappingTypes> responseObserver) {
+            responseObserver.onNext(WrappingTypes.newBuilder()
+                .addWrappingType(WrappingType.newBuilder().setWrappingType("standardPackaging").build())
+                .addWrappingType(WrappingType.newBuilder().setWrappingType("giftWrap").build())
+                .build());
+            responseObserver.onCompleted();
+        }
+    }
+
+    @Before
+    public void setUp() throws IOException {
+        MockitoAnnotations.openMocks(this);
+
+        serverName = InProcessServerBuilder.generateName();
+
+        GrpcServiceConfig config = new GrpcServiceConfig();
+        packagingImpl = new TestPackagingImpl(config);
+
+        grpcCleanup.register(InProcessServerBuilder
+                .forName(serverName)
+                .directExecutor()
+                .addService(packagingImpl)
+                .build()
+                .start());
+
+        blockingStub = PackagingGrpc.newBlockingStub(
+                grpcCleanup.register(InProcessChannelBuilder
+                        .forName(serverName)
+                        .directExecutor()
+                        .build()));
+    }
+
+    @Test
+    public void testWrapShirts() {
+        WrapRequest request = WrapRequest.newBuilder()
+                .addAllShirts(createMockShirts(5))
+                .build();
+
+        PackedShirts response = blockingStub.wrapShirts(request);
+
+        assertNotNull(response);
+        assertEquals(5, response.getShirtsCount());
+    }
+
+    @Test
+    public void testGiftWrap() {
+        WrapRequest request = WrapRequest.newBuilder()
+                .addAllShirts(createMockShirts(3))
+                .build();
+
+        GiftPack response = blockingStub.giftWrap(request);
+
+        assertNotNull(response);
+        assertNotNull(response.getGiftMaterial());
+    }
+
+    @Test
+    public void testRestockMaterial() {
+        WrappingType wrappingType = WrappingType.newBuilder()
+                .setWrappingType("standardPackaging")
+                .build();
+
+        Status response = blockingStub.restockMaterial(wrappingType);
+
+        assertNotNull(response);
+        assertEquals(true, response.getStatus());
+    }
+
+    @Test
+    public void testGetPackingTypes() {
+        Void request = Void.newBuilder().build();
+        PackagingGrpc.PackagingStub asyncStub = PackagingGrpc.newStub(
+                grpcCleanup.register(InProcessChannelBuilder
+                        .forName(serverName)
+                        .directExecutor()
+                        .build()));
+
+        asyncStub.getPackingTypes(request, responseObserver);
+
+        verify(responseObserver).onNext(any(WrappingTypes.class));
+        verify(responseObserver).onCompleted();
+    }
+
+    private List<Shirt> createMockShirts(int count) {
+        List<Shirt> shirts = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            shirts.add(Shirt.newBuilder()
+                    .setStyle(ShirtStyle.newBuilder().setName("style" + i).build())
+                    .build());
+        }
+        return shirts;
+    }
+}

packaging/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

@@ -0,0 +1 @@
+mock-maker-inline

pom.xml

@@ -157,6 +157,38 @@
             <artifactId>log4j-layout-template-json</artifactId>
             <version>2.19.0</version>
         </dependency>
+
+        <!-- Test Dependencies -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>4.11.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard</groupId>
+            <artifactId>dropwizard-testing</artifactId>
+            <version>${dropwizard.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-testing</artifactId>
+            <version>${grpc.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <version>${spring.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>