diff --git a/axon/src/test/java/com/baeldung/axon/commandmodel/OrderAggregateUnitTest.java b/axon/src/test/java/com/baeldung/axon/commandmodel/OrderAggregateUnitTest.java
index aaefe49fb1..262a8f1e03 100644
--- a/axon/src/test/java/com/baeldung/axon/commandmodel/OrderAggregateUnitTest.java
+++ b/axon/src/test/java/com/baeldung/axon/commandmodel/OrderAggregateUnitTest.java
@@ -1,62 +1,139 @@
 package com.baeldung.axon.commandmodel;
 
-import java.util.UUID;
-
-import com.baeldung.axon.coreapi.exceptions.UnconfirmedOrderException;
-import org.axonframework.test.aggregate.AggregateTestFixture;
-import org.axonframework.test.aggregate.FixtureConfiguration;
-import org.junit.*;
-
+import com.baeldung.axon.commandmodel.order.OrderAggregate;
+import com.baeldung.axon.coreapi.commands.AddProductCommand;
 import com.baeldung.axon.coreapi.commands.ConfirmOrderCommand;
+import com.baeldung.axon.coreapi.commands.DecrementProductCountCommand;
+import com.baeldung.axon.coreapi.commands.IncrementProductCountCommand;
 import com.baeldung.axon.coreapi.commands.PlaceOrderCommand;
 import com.baeldung.axon.coreapi.commands.ShipOrderCommand;
 import com.baeldung.axon.coreapi.events.OrderConfirmedEvent;
 import com.baeldung.axon.coreapi.events.OrderPlacedEvent;
 import com.baeldung.axon.coreapi.events.OrderShippedEvent;
+import com.baeldung.axon.coreapi.events.ProductAddedEvent;
+import com.baeldung.axon.coreapi.events.ProductCountDecrementedEvent;
+import com.baeldung.axon.coreapi.events.ProductCountIncrementedEvent;
+import com.baeldung.axon.coreapi.events.ProductRemovedEvent;
+import com.baeldung.axon.coreapi.exceptions.DuplicateOrderLineException;
+import com.baeldung.axon.coreapi.exceptions.OrderAlreadyConfirmedException;
+import com.baeldung.axon.coreapi.exceptions.UnconfirmedOrderException;
+import org.axonframework.test.aggregate.AggregateTestFixture;
+import org.axonframework.test.aggregate.FixtureConfiguration;
+import org.axonframework.test.matchers.Matchers;
+import org.junit.jupiter.api.*;
 
-public class OrderAggregateUnitTest {
+import java.util.UUID;
+
+class OrderAggregateUnitTest {
+
+    private static final String ORDER_ID = UUID.randomUUID().toString();
+    private static final String PRODUCT_ID = UUID.randomUUID().toString();
 
     private FixtureConfiguration<OrderAggregate> fixture;
 
-    @Before
-    public void setUp() {
+    @BeforeEach
+    void setUp() {
         fixture = new AggregateTestFixture<>(OrderAggregate.class);
     }
 
     @Test
-    public void giveNoPriorActivity_whenPlaceOrderCommand_thenShouldPublishOrderPlacedEvent() {
-        String orderId = UUID.randomUUID().toString();
-        String product = "Deluxe Chair";
+    void giveNoPriorActivity_whenPlaceOrderCommand_thenShouldPublishOrderPlacedEvent() {
         fixture.givenNoPriorActivity()
-               .when(new PlaceOrderCommand(orderId, product))
-               .expectEvents(new OrderPlacedEvent(orderId, product));
+               .when(new PlaceOrderCommand(ORDER_ID))
+               .expectEvents(new OrderPlacedEvent(ORDER_ID));
     }
 
     @Test
-    public void givenOrderPlacedEvent_whenConfirmOrderCommand_thenShouldPublishOrderConfirmedEvent() {
-        String orderId = UUID.randomUUID().toString();
-        String product = "Deluxe Chair";
-        fixture.given(new OrderPlacedEvent(orderId, product))
-               .when(new ConfirmOrderCommand(orderId))
-               .expectEvents(new OrderConfirmedEvent(orderId));
+    void givenOrderPlacedEvent_whenAddProductCommand_thenShouldPublishProductAddedEvent() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID))
+               .when(new AddProductCommand(ORDER_ID, PRODUCT_ID))
+               .expectEvents(new ProductAddedEvent(ORDER_ID, PRODUCT_ID));
     }
 
     @Test
-    public void givenOrderPlacedEvent_whenShipOrderCommand_thenShouldThrowUnconfirmedOrderException() {
-        String orderId = UUID.randomUUID().toString();
-        String product = "Deluxe Chair";
-        fixture.given(new OrderPlacedEvent(orderId, product))
-               .when(new ShipOrderCommand(orderId))
+    void givenOrderPlacedEventAndProductAddedEvent_whenAddProductCommandForSameProductId_thenShouldThrowDuplicateOrderLineException() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID), new ProductAddedEvent(ORDER_ID, PRODUCT_ID))
+               .when(new AddProductCommand(ORDER_ID, PRODUCT_ID))
+               .expectException(DuplicateOrderLineException.class)
+               .expectExceptionMessage(Matchers.predicate(message -> ((String) message).contains(PRODUCT_ID)));
+    }
+
+    @Test
+    void givenOrderPlacedEventAndProductAddedEvent_whenIncrementProductCountCommand_thenShouldPublishProductCountIncrementedEvent() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID), new ProductAddedEvent(ORDER_ID, PRODUCT_ID))
+               .when(new IncrementProductCountCommand(ORDER_ID, PRODUCT_ID))
+               .expectEvents(new ProductCountIncrementedEvent(ORDER_ID, PRODUCT_ID));
+    }
+
+    @Test
+    void givenOrderPlacedEventProductAddedEventAndProductCountIncrementedEvent_whenDecrementProductCountCommand_thenShouldPublishProductCountDecrementedEvent() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID),
+                      new ProductAddedEvent(ORDER_ID, PRODUCT_ID),
+                      new ProductCountIncrementedEvent(ORDER_ID, PRODUCT_ID))
+               .when(new DecrementProductCountCommand(ORDER_ID, PRODUCT_ID))
+               .expectEvents(new ProductCountDecrementedEvent(ORDER_ID, PRODUCT_ID));
+    }
+
+    @Test
+    void givenOrderPlacedEventAndProductAddedEvent_whenDecrementProductCountCommand_thenShouldPublishProductRemovedEvent() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID), new ProductAddedEvent(ORDER_ID, PRODUCT_ID))
+               .when(new DecrementProductCountCommand(ORDER_ID, PRODUCT_ID))
+               .expectEvents(new ProductRemovedEvent(ORDER_ID, PRODUCT_ID));
+    }
+
+    @Test
+    void givenOrderPlacedEvent_whenConfirmOrderCommand_thenShouldPublishOrderConfirmedEvent() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID))
+               .when(new ConfirmOrderCommand(ORDER_ID))
+               .expectEvents(new OrderConfirmedEvent(ORDER_ID));
+    }
+
+    @Test
+    void givenOrderPlacedEventAndOrderConfirmedEvent_whenConfirmOrderCommand_thenExpectNoEvents() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID), new OrderConfirmedEvent(ORDER_ID))
+               .when(new ConfirmOrderCommand(ORDER_ID))
+               .expectNoEvents();
+    }
+
+    @Test
+    void givenOrderPlacedEvent_whenShipOrderCommand_thenShouldThrowUnconfirmedOrderException() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID))
+               .when(new ShipOrderCommand(ORDER_ID))
                .expectException(UnconfirmedOrderException.class);
     }
 
     @Test
-    public void givenOrderPlacedEventAndOrderConfirmedEvent_whenShipOrderCommand_thenShouldPublishOrderShippedEvent() {
-        String orderId = UUID.randomUUID().toString();
-        String product = "Deluxe Chair";
-        fixture.given(new OrderPlacedEvent(orderId, product), new OrderConfirmedEvent(orderId))
-               .when(new ShipOrderCommand(orderId))
-               .expectEvents(new OrderShippedEvent(orderId));
+    void givenOrderPlacedEventAndOrderConfirmedEvent_whenShipOrderCommand_thenShouldPublishOrderShippedEvent() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID), new OrderConfirmedEvent(ORDER_ID))
+               .when(new ShipOrderCommand(ORDER_ID))
+               .expectEvents(new OrderShippedEvent(ORDER_ID));
     }
 
+    @Test
+    void givenOrderPlacedEventProductAndOrderConfirmedEvent_whenAddProductCommand_thenShouldThrowOrderAlreadyConfirmedException() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID), new OrderConfirmedEvent(ORDER_ID))
+               .when(new AddProductCommand(ORDER_ID, PRODUCT_ID))
+               .expectException(OrderAlreadyConfirmedException.class)
+               .expectExceptionMessage(Matchers.predicate(message -> ((String) message).contains(ORDER_ID)));
+    }
+
+    @Test
+    void givenOrderPlacedEventProductAddedEventAndOrderConfirmedEvent_whenIncrementProductCountCommand_thenShouldThrowOrderAlreadyConfirmedException() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID),
+                      new ProductAddedEvent(ORDER_ID, PRODUCT_ID),
+                      new OrderConfirmedEvent(ORDER_ID))
+               .when(new IncrementProductCountCommand(ORDER_ID, PRODUCT_ID))
+               .expectException(OrderAlreadyConfirmedException.class)
+               .expectExceptionMessage(Matchers.predicate(message -> ((String) message).contains(ORDER_ID)));
+    }
+
+    @Test
+    void givenOrderPlacedEventProductAddedEventAndOrderConfirmedEvent_whenDecrementProductCountCommand_thenShouldThrowOrderAlreadyConfirmedException() {
+        fixture.given(new OrderPlacedEvent(ORDER_ID),
+                      new ProductAddedEvent(ORDER_ID, PRODUCT_ID),
+                      new OrderConfirmedEvent(ORDER_ID))
+               .when(new DecrementProductCountCommand(ORDER_ID, PRODUCT_ID))
+               .expectException(OrderAlreadyConfirmedException.class)
+               .expectExceptionMessage(Matchers.predicate(message -> ((String) message).contains(ORDER_ID)));
+    }
 }
\ No newline at end of file