Test your Rule

Unit Testing

• Create a fully Mocked Unit Test (using IDE's Unit Testing capabilities) for your custom Rule. In the Mocked unit test perform one (1) assertion per test case and test both positive and negative paths.
• Test your Rule in the TestExecutor.  The TestExecuter can be viewed as a mini Workflow Engine simulator that runs on your local machine to assert additional behavior.
• Deploy your plugin to your Sandbox account.

Mocked Unit Testing

Create a Mocked Unit Test class for your custom Rule

• Open your plugin project in which you have written the MarkOrderHighValueRule class.
• In the src/test/java/com.training/rule folder of your plugin project, create a new class named MarkOrderHighValueRuleTest.
• Write a setup method to initiate the mocks. This setup method will run before every test in the class. The setup method uses MockitoAnnotations class to initiate Mocks(initMocks). Mockito is the Fluent mocking framework.
• Define a mock on Context, which is a required parameter of the run method in the Rule class.

• Make sure you import the v2 version of Context i.e use this package com.fluentretail.rubix.v2.context.Context
• The org.mockito package can mock all classes except final classes. 

1
2    package com.training.rule;
3
4    public class MarkOrderHighValueRuleTest 
5    {
6
7        private MarkOrderHighValueRule rule = new MarkOrderHighValueRule();
8
9        @Mock
10
11        private Context context;
12
13        @Before
14
15        public void setup() 
16        {
17
18            MockitoAnnotations.initMocks(this);
19
20        }
21
22    }

Use Mockito to write test cases

1/**
2 * NOTE: This is a snippet from `MarkOrderHighValueRule class from 'Writing the Rules' section
3 **/
4
5// Validation:
6Integer threshold = context.getProp(Constants.PARAM_NAME_HIGH_VALUE_THRESHOLD, Integer.class);
7if (null == threshold) 
8{
9    throw new PropertyNotFoundException(400,String.format("Required Parameter not provided: %s", Constants.PARAM_NAME_HIGH_VALUE_THRESHOLD));
10}

• Create a test method named run_withMissingThresholdParam_ThrowsPropertyNotFoundException ( ).
• The run method throws a PropertyNotFoundException, so we don't need any assertion in the Test case.  The Test expected behaviour will manage the exception with the following line of code: @Test(expected = PropertyNotFoundException.class)
• Use a negative path test: In the arrange section of the Test,  get the property. If the property returned is null, then it throws an exception.  
• Run the test case: On IntelliJ use control+shift+R key code. Or, right-click inside the method, and select run_withMissingThresholdParam_ThrowsPropertyNotFoundException method. 

1<dependency>
2        <groupId>org.powermock</groupId>
3        <artifactId>powermock-module-junit4</artifactId>
4        <version>1.6.6</version>
5        <scope>test</scope>
6    </dependency>
7    <dependency>
8        <groupId>org.powermock</groupId>
9        <artifactId>powermock-api-mockito</artifactId>
10        <version>1.6.6</version>
11        <scope>test</scope>
12    </dependency>

Include PowerMock and prepare to write the test case

• Open the pom.xml file in your project. 
• Copy the dependencies ( provided below) under the existing Mockito dependency
•  Check the scope is set to test
•  Clean the Maven project.

• As we are using PowerMock, we need to define a different test runner for PowerMock. Refer to the table below to define and prepare the test runner class for PowerMock

• Define the following Mocks in your testing class 

1// Required Mocks
2@Mock
3private Event event;
4@Mock
5private ReadOnlyFluentApiClient apiClient;
6@Mock
7private GetOrderByIdQuery.Data data;
8@Mock
9private GetOrderByIdQuery.OrderById orderById;
10@Mock
11private ActionFactory actionFactory;

• Define/Write the default behaviour of above defined Mocks in the setup ( ) method.

• PARAM_NAME_HIGH_VALUE_THRESHOLD value - returns the default value of $1000  
• (context.getEvent()) - it will return the mocked event value
• event.getEntityId()) - will return the default String value of  "123"
• Other context values - context.api() , apiClient.query(any(), data.orderById() will return respective mocked values

Create a test case using PowerMock

• Create a test method named as     run_withValueGreaterThanThreshold_queuesUpdateOrderAttributesMutation()
• The "arrange, act and assert" approach of the test method is explained in the given below interaction (See diagram below).
• Run the test case: On IntelliJ use  control+shift+R key code. Or, right-click inside the method, and select run run_withValueGreaterThanThreshold_queuesUpdateOrderAttributesMutation() method. 

• Arrange - if the order's totalprice value is greater than the default value set in the setup() method then it will return value greater than default value for totalPrice. It also returns mocked actionFactory.

• Act - it will make the rule run on the mocked context.
• Assert - It will verify that the mutation is called only one time and is of any UpdateOrder type.

Write another test case using PowerMock

• Prepare PowerMockRunner by updating @PrepareForTest annotation to include AttributeInput.class . Your annotation should look like:

• Define a Mock of AttributeInput.Builder by using the below code. This will allow us to verify that the Attribute Name is set correctly.

• Create a test method named  run_withValueGreaterThanThreshold_addsAttributeWithNameIsHighValue() which throws Exception
• Use the given below code for this test case.
• Run the test case.

1@Test
2    public void run_withValueGreaterThanThreshold_addsAttributeWithNameIsHighValue() throws Exception {
3
4        //arrange:
5        when(orderById.totalPrice()).thenReturn(1001.00);
6        when(context.action()).thenReturn(actionFactory);
7
8        AttributeInput attributeInput = AttributeInput.builder().name("test-name").type("test-type").value("test-value").build();
9        PowerMockito.whenNew(AttributeInput.Builder.class).withNoArguments().thenReturn(mockedAttributeInputBuilder);
10        when(mockedAttributeInputBuilder.name(anyString())).thenReturn(mockedAttributeInputBuilder);
11        when(mockedAttributeInputBuilder.type(anyString())).thenReturn(mockedAttributeInputBuilder);
12        when(mockedAttributeInputBuilder.value(any())).thenReturn(mockedAttributeInputBuilder);
13        when(mockedAttributeInputBuilder.build()).thenReturn(attributeInput);
14
15        //act:
16        rule.run(context);
17
18        //assert:
19        verify(mockedAttributeInputBuilder, times(1)).name(Constants.IS_HIGH_VALUE_ORDER_ATTRIBUTE_NAME);
20    }

Practice Exercises

• run_withValueGreaterThanThreshold_addsAttributeWithTypeBoolean
• run_withValueGreaterThanThreshold_addsAttributeWithValueTrue
• run_withValueLessThanThreshold_doesNotQueueAnyMutation
• run_withValueLessThanThreshold_doesNotBuildAnyAttribute
• run_withValueEqualThanThreshold_doesNotQueueAnyMutation
• run_withValueEqualThanThreshold_doesNotBuildAnyAttribute

Testing on the TestExecutor

• rule(Class.class): load a rule
• ruleset(RuleSet ruleSet): adds a ruleset to the workflow
• entity(Entity entity): adds an entity to the workflow
• validateWorkflow(Event event): validates the workflow with the given event
• execute(Event event): executes the workflow with the given event

• count*(): Provides access to the number of events or actions that have been executed in the context.
• get*(): Provides access to the entities, rules, events, and properties.

• run_withTotalPriceGreaterThanThreshold_callsMutateAction
• run_withTotalPriceLessThanThreshold_doesNotCallMutateAction
• run_withTotalPriceGreaterThanThreshold_doesNotCallMutateAction

Step 1 - Create a test class

1public class MarkOrderHighValueRuleExecutorTest {
2
3    private static final Integer HIGH_VALUE_THRESHOLD = 1000;
4    private static final String ORDER_ID = "123";
5
6    private TestExecutor executor;
7
8    private Event event;
9
10    @Mock
11    private ReadOnlyFluentApiClient apiClient;
12
13    @Mock
14    private GetOrderByIdQuery.Data data;
15
16    @Before
17    public void setup() {
18
19        MockitoAnnotations.initMocks(this);
20
21        when(apiClient.query(any())).thenReturn(data);
22    }
23}

Step 2 - Create an Event entity

1@Before
2    public void setup() {
3
4        MockitoAnnotations.initMocks(this);
5
6        when(apiClient.query(any())).thenReturn(data);
7
8        // Setup up an instance of a Rubix Entity
9        RubixEntity entity = RubixEntity.builder()
10            .status("BOOKED")
11            .entityType("ORDER")
12            .flexType("flexType")
13            .flexVersion(1)
14            .ref(ORDER_ID)
15            .id(UUID.randomUUID().toString())
16            .build();
17
18    }

Step 3 - Create an Event to trigger the Ruleset

• Event.builder on declared Event instance - Use Event builder to build the event with the attributes of retailerID, entityID, rootEntityRef, etc.
• Event.builder.build  - Once the event is built, it will be used to trigger the workflow.

Step 4 - Create the Rule instance and Ruleset

• The Rule we are going to test. 
• Setup the Ruleset- ruleset configured with an instance of the Rule, an Entity, and an Event.

• Create a map in the setup() method to show how the Rule is configured with Rule parameters in the Ruleset.
• Create an instance of a Ruleset in the setup() method to hold an instance of the Rule that is configured with the parameters as shown in the interaction below

• map of rule parameters - ImmutableMap will map required parameters of the Rule.
• event paramater of ruleset - It is the event that is triggering the ruleset.
• name of the rule  - MarkOrderHighValueRule.class.getSimpleName() is the name of the Rule class
• map builder - propertyBuilder.build() is the map builder that states how the rule is configured

Step 5 - Setup the TestExecutor

1// Set up a TestExecutor to simulate Orchestration Engine
2        executor = TestExecutor.builder()
3            .rule(MarkOrderHighValueRule.class)
4            .ruleset(ruleSet)
5            .entity(entity)
6            .testApiClient(apiClient)
7            .build();

Step 6 - Create a test case to run on TestExecutor

• Create a test method named run_withTotalPriceGreaterThanThreshold_callsMutateAction
• The test method "arrange, act and assert" approach is in the below-given code snippet. 
• Run the test case.

1@Test
2    public void run_withTotalPriceGreaterThanThreshold_callsMutateAction() {
3
4        // arrange:
5        GetOrderByIdQuery.OrderById orderById = GetOrderByIdQuery.OrderById.builder().id(ORDER_ID).totalPrice(1001.00).type("type").__typename("type-name").build();
6
7        when(data.orderById()).thenReturn(orderById);
8
9        executor.validateWorkflow(event);
10
11        // act:
12        TestContext context = executor.execute(event);
13
14        // assert:
15        assertEquals(1, context.countActionsOfType(TestContext.MutateAction.class));
16    }

Practice Exercises

• run_withTotalPriceLessThanThreshold_doesNotCallMutateAction
• run_withTotalPriceEqualToThreshold_doesNotCallMutateA

Testing on Sandbox