JUnit – Inventory Stock Testing as a Maven Project
The quality of the software is very important. Though Unit tests and integration tests are done in the manual testing way, we cannot expect all kinds of scenarios to test. Hence as a testing mechanism, we can test a software code or project by means of JUnit. In this article let us see how to do testing for inventory stock by using JUnit. Via a Maven project, let us see the project concept
Project Structure:
Let us see the dependencies of this project via
pom.xml
XML
<? xml version = "1.0" encoding = "UTF-8" ?> < project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> < modelVersion >4.0.0</ modelVersion > < groupId >com.gfg.stock</ groupId > < artifactId >StockService</ artifactId > < packaging >jar</ packaging > < version >1.0-SNAPSHOT</ version > < properties > <!-- https://maven.apache.org/general.html#encoding-warning --> < project.build.sourceEncoding >UTF-8</ project.build.sourceEncoding > < maven.compiler.source >1.8</ maven.compiler.source > < maven.compiler.target >1.8</ maven.compiler.target > < junit.version >5.3.1</ junit.version > < pitest.version >1.4.3</ pitest.version > </ properties > < dependencies > <!-- junit 5, unit test --> <!-- This is the much desired dependency and then only we can do testing --> < dependency > < groupId >org.junit.jupiter</ groupId > < artifactId >junit-jupiter-engine</ artifactId > < version >${junit.version}</ version > < scope >test</ scope > </ dependency > </ dependencies > < build > < finalName >maven-mutation-testing</ finalName > < plugins > < plugin > < groupId >org.apache.maven.plugins</ groupId > < artifactId >maven-surefire-plugin</ artifactId > < version >3.0.0-M1</ version > </ plugin > < plugin > < groupId >org.pitest</ groupId > < artifactId >pitest-maven</ artifactId > < version >${pitest.version}</ version > < executions > < execution > < id >pit-report</ id > < phase >test</ phase > < goals > < goal >mutationCoverage</ goal > </ goals > </ execution > </ executions > <!-- https://github.com/hcoles/pitest/issues/284 --> <!-- Need this to support JUnit 5 --> < dependencies > < dependency > < groupId >org.pitest</ groupId > < artifactId >pitest-junit5-plugin</ artifactId > < version >0.8</ version > </ dependency > </ dependencies > < configuration > < targetClasses > < param >com.gfg.stock.*Stock*</ param > </ targetClasses > < targetTests > < param >com.gfg.stock.*</ param > </ targetTests > </ configuration > </ plugin > </ plugins > </ build > </ project > |
Let us see the business logic file
StockService.java
Java
public class StockService { // instance variable private int qtyOnHand; // Parameterized constructor used to // initialize the value of qtyOnHand public StockService( int qtyOnHand) { this .qtyOnHand = qtyOnHand; } // While adding stock items, we have to // check whether is it positive or not private void isValidQty( int quantity) { if (quantity < 0 ) { throw new IllegalArgumentException( "Given stock quantity should be positive!" ); } } // While adding the stock, we have to check whether // input quantity is positive // and if so, it will get added with the existing stock public int addTheStock( int qty) { isValidQty(qty); qtyOnHand = qtyOnHand + qty; return qtyOnHand; } // While deducting the stock, we have to check // whether input quantity is positive // and if so, we need to check are we deducting the // stock with the available quantity // Eg : if there are 100 quantities available, only // that 100 quantity can be deducted // If we pass 101 items to get deducted, logivally it is wrong public int deductTheStock( int qty) { isValidQty(qty); int newQty = qtyOnHand - qty; if (newQty < 0 ) { throw new IllegalArgumentException( "Out of Stock!" ); } else { qtyOnHand = newQty; } return qtyOnHand; } } |
Now we need to see the test file that can help for automated testing via JUnit
TestStockService.java
Java
package com.gfg.stock; import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; public class TestStockService { @DisplayName ( "Test deduct stock" ) @Test public void testDeductTheStock() { // Initializing the stock to have 100 quantities StockService obj = new StockService( 100 ); // If we remove 10 stocks, the expected // result is 90-> (100 - 10) assertEquals( 90 , obj.deductTheStock( 10 )); // If we remove 90 stocks, the expected result is 0 assertEquals( 0 , obj.deductTheStock( 90 )); assertEquals( 0 , obj.deductTheStock( 0 )); Assertions.assertThrows(IllegalArgumentException. class , () -> { obj.deductTheStock(- 1 ); }); // As while reaching this point, we do not have any // stock because of previous deductions // hence stock has gone to negative value // and hence this is correct Assertions.assertThrows(IllegalArgumentException. class , () -> { obj.deductTheStock( 100 ); }); } @DisplayName ( "Test add stock" ) @Test public void testAddTheStock() { // Initializing the stock to have 100 quantities StockService obj = new StockService( 100 ); // If we add 10 more stocks, the expected result is 110 assertEquals( 110 , obj.addTheStock( 10 )); assertEquals( 110 , obj.addTheStock( 0 )); // Need to show errors when negative quantity is added Assertions.assertThrows(IllegalArgumentException. class , () -> { obj.addTheStock(- 1 ); }); } } |
Let us test the scenarios by using the JUNIT Testcase execution
Output:
In case the business logic is written wrongly or the way of comparing the values is wrong, then we will end up with errors let us see one such scenario
Java
@Test public void testDeductTheStock() { StockService obj = new StockService( 100 ); // Here after deduction of 10 quantities, result will become 90 // But while testing, it has been provided with 100, which is wrong assertEquals( 100 , obj.deductTheStock( 10 )); //.... } |
Conclusion
JUnit is very helpful to find the errors. Manual testing will lead to human errors because we cannot predict all the scenarios. Hence nowadays to qualify a software product, mandatorily one has to check them with JUnit.