JUnit Testing for SAP Commerce: How to Increase Quality

In a complex system such as SAP Commerce, manual testing alone is not sufficient to guarantee the quality of the software, robust testing is required to ensure its stability, reliability, and security. This is where automation testing comes into play. 

In this blog post, we will take a closer look at JUnit testing in SAP Commerce, including its benefits, how to write and execute JUnit tests in SAP Commerce, and some best practices for JUnit testing in SAP Commerce. 

Setting up JUnit in SAP Commerce 

The first step in using JUnit in SAP Commerce is to set up your environment. You will need to have Java and Apache Ant installed on your machine. Once you have these installed, you can create a new JUnit test class in your SAP Commerce project. You can do this by creating a new Java class and importing the JUnit library. 

Writing a test class 

To start you need to create a new class and annotate it with “@UnitTest“, then create a new test method that tests the functionality of a specific piece of code using the annotation “@Test“. You can use JUnit assertions to check that the code is working as expected. Assertions are simple statements that evaluate to true or false. For example, you might write an assertion that checks that the result of a calculation is equal to a certain value. 

@UnitTest
public class DefaultVendorOrderTotalPriceCalculationStrategyTest
{
   private DefaultVendorOrderTotalPriceCalculationStrategy defaultConsignmentTotalPriceCalculationStrategy;

   private ConsignmentModel consignment;

   @Before
   public void prepare()
   {
      defaultConsignmentTotalPriceCalculationStrategy = new DefaultVendorOrderTotalPriceCalculationStrategy();
      consignment = new ConsignmentModel();
      final AbstractOrderEntryModel orderEntry1 = new OrderEntryModel();
      orderEntry1.setTotalPrice(0.01);
      final AbstractOrderEntryModel orderEntry2 = new OrderEntryModel();
      orderEntry2.setTotalPrice(0.02);
      final ConsignmentEntryModel consignmentEntry1 = new ConsignmentEntryModel();
      consignmentEntry1.setOrderEntry(orderEntry1);
      final ConsignmentEntryModel consignmentEntry2 = new ConsignmentEntryModel();
      consignmentEntry2.setOrderEntry(orderEntry2);
      consignment.setConsignmentEntries(new HashSet<>(Arrays.asList(consignmentEntry1, consignmentEntry2)));
   }

   @Test
   public void testCalculateTotalPrice()
   {
      final double totalPrice = defaultConsignmentTotalPriceCalculationStrategy.calculateTotalPrice(consignment);
      Assert.assertEquals(0.03, totalPrice, 0.000001);
   }

}

Annotations in Junit 

In addition to assertions, JUnit provides several annotations to define and customize test cases. Annotations are special markers that you can apply to methods, classes, or fields to provide additional information or instructions to the testing framework. Here are some of the most used annotations in JUnit: 

• @Test: marks a method as a test method. JUnit will run all methods annotated with @Test.
• @Before: specifies that a method should be run before each test method. Typically, this method is used to set up any required resources for the test.
• @After: marks a method that should be run after each test method. Typically, this method is used to clean up any resources used by the test.
• @BeforeClass: used for methods to be run once before any test methods are run. Typically used to set up any resources that are expensive to create and can be reused across multiple tests.
• @AfterClass: marks a method that should be run once after all test methods have been run. Typically, this method is used to clean up any resources created by the @BeforeClass method.
• @Ignore: this is useful when a test method is temporarily not working or when you want to skip a test method for some reason, JUnit ignores all methods with this mark.
• @RunWith: specify a custom test runner for the test class. The test runner is responsible for running the test methods and reporting the results.

@BeforeClass
public static void createValidator() {
    validatorFactory = Validation.buildDefaultValidatorFactory();
    validator = validatorFactory.getValidator();
}

@AfterClass
public static void close() {
    validatorFactory.close();
}

@Test
public void shouldNotReturnViolation() {
    EndUserQuoteEditForm form = new EndUserQuoteEditForm();
    form.setCustomerReference("VALIDREFERENCEFORCARTCART");
    Set<ConstraintViolation<EndUserQuoteEditForm>> violations = validator.validate(form);
    assertTrue(violations.isEmpty());
}

@Test
public void shouldReturnViolation_specialCharacters() {
    EndUserQuoteEditForm form = new EndUserQuoteEditForm();
    form.setCustomerReference(" crazy %Stri*ng& ");
    Set<ConstraintViolation<EndUserQuoteEditForm>> violations = validator.validate(form);
    assertFalse(violations.isEmpty());
}

Running JUnit tests in SAP Commerce 

Once you have written your test class, you can run it in SAP Commerce. To do this, you will need to build your project using Apache Ant. When you build your project, the JUnit tests will be executed, and any errors or failures will be reported. 

SAP Commerce also provides several tools to help you debug your tests. For example, you can use the HybrisJUnitRunner, which allows you to run your tests in a specific order and to set up your test environment. 

Best practices for JUnit testing  

When writing JUnit tests in SAP Commerce, there are a few best practices that you should follow to ensure that your tests are effective and maintainable. 

Use descriptive names for your test methods: The name of your test method should describe what the test is checking. This makes it easier to understand what your tests are doing and to identify any issues. 

Keep your tests independent: Each test method should be independent of other test methods. This means that each test should be able to run on its own without relying on any other tests. 

Use annotations to set up your test environment: When writing tests, you should use fixtures to set up your test environment. This ensures that your tests are consistent and repeatable. 

Test edge cases: It is important to test edge cases to ensure that your code can handle unexpected situations. For example, you might test how your code handles null values or large input values. 

Write tests for new features: Whenever you add a new feature to your SAP Commerce project, you should write tests to ensure that the feature is working as expected. 

Benefits of JUnit testing 

There are many benefits to automation testing in SAP Commerce: 

• Increased speed and efficiency: JUnit can run tests faster and more efficiently than manual testing, which can save time and reduce costs. 

• Improved accuracy and reliability: JUnit is less prone to human error, which can improve the accuracy and reliability of testing. 
• Enhanced test coverage: JUnit can test more scenarios and use cases than manual testing, which can increase the overall test coverage and catch more defects and errors. 
• Better feedback and reporting: JUnit can provide real-time feedback and reporting on test results, which can help developers identify and fix issues more quickly. 

In conclusion, JUnit testing is a powerful tool for improving the quality of your code in SAP Commerce. By writing effective tests, you can ensure that your code is working as expected and that changes do not introduce new bugs. By following best practices and using SAP Commerce tools, you can create a robust testing process that will help you to deliver high-quality e-commerce solutions.