We use assert to test our condition but ssert will not give us more infrmation if test falied means it will not give us the expected value and actual value to solve this issue we will use assertion instead of assert. like Assertions.assertTrue(condition) or Assertions.assertEquals(expectedValue, actualValue)

public class DemoTest {
@Test
public void addition(){
// Arrange
int a = 10, b
int x = a + b;
// Assert
// assert x == 30;
// Assertions.assertTrue(x == 30);
Assertions.assertEquals(30, x);

}

}

Assertions.assertThrows -> Assertions.assertThrows is a method, such as JUnit or TestNG, to verify that a specific exception is thrown by a piece of code during testing. Assertions.assertThrows takes two parameters: the expected exception type and the executable code block where the exception is expected to be thrown. When we delve into the method’s implementation, we encounter an “executable,” which anticipates a functional component. In threads, when implementing an interface, we typically create a class or an anonymous class. However, if it’s a functional component, we can simply pass a lambda expression. Similarly, in this context, we utilize a lambda expression as the second parameter, containing the executable code where the exception is anticipated.

Here’s how it works:

package com.onlineshop.shop;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
assertThrows(ExpectedException.class, () -> {
// Code that should throw ExpectedException
// If this code does not throw ExpectedException, the test will fail
});

ExpectedException.class: This is the type of exception that you expect to be thrown by the code under test.

() -> { /* Code block */ }: This is a lambda expression representing the code that you expect to throw the exception. The assertThrows method will execute this code and verify that it throws the expected exception.

If the code block does not throw the expected exception, the test will fail with an assertion error.

Here’s a practical example:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class MyTest {
@Test
public void testDivideByZero() {
assertThrows(ArithmeticException.class, () -> {
int result = 10 / 0; // This should throw an ArithmeticException
});
}
}

In this example, the test method testDivideByZero verifies that dividing by zero throws an ArithmeticException. If the division operation does not throw the expected exception, the test will fail.

Assertions.assertArrayEquals : is a method used to compare two arrays for equality in Java testing. It verifies that two arrays are equal to each other in terms of their contents. Here’s how it

assertArrayEquals(expectedArray, actualArray);

• expectedArray: This is the array that contains the expected values.

• actualArray: This is the array that contains the actual values.

If the contents of the expectedArray and actualArray are not equal, the test will fail and an assertion error will be thrown.

Here’s a practical example:
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
public class MyTest {
@Test
public void testArrayEquality() {
int[] expectedArray = {1, 2, 3};
int[] actualArray = {1, 2, 3};
assertArrayEquals(expectedArray, actualArray);
}
}

In this example, the test method testArrayEquality verifies that the expectedArray is equal to the actualArray. If the arrays are not equal, the test will fail.

Assertions.assertLinesMatch: When comparing lists of strings, we utilize Assertions.assertLinesMatch. This method requires two parameters: the expected list followed by the actual list.

public class DemoTest {
@Test
public void addition(){
List<String> expected = Arrays.asList(“sanjay”, “vinod”);
List<String> actial = Arrays.asList(“sanjay”, “vinod”);
Assertions.assertLinesMatch(expected,actial)
}
}

Assertions.assertTimeout -> verify that a piece of code executes within a specified time limit. It ensures that the execution time of a particular operation does not exceed a certain threshold. Here’s how it works:

assertTimeout(Duration.ofMillis(timeout), () -> {

// Code block to be executed within the timeout duration

});

• Duration.ofMillis(timeout): This specifies the maximum duration for which the code block is allowed to execute. You can specify the timeout duration in milliseconds (or other time units such as seconds, minutes, etc.).

• () -> { /* Code block */ }: This is a lambda expression representing the code that you want to execute within the specified timeout duration. The assertTimeout method will execute this code and ensure that it completes within the specified time limit.

If the code block takes longer than the specified timeout duration to execute, the test will fail with an assertion error.

Here’s a practical example:
import org.junit.jupiter.api.Test;
import java.time.Duration;
import static org.junit.jupiter.api.Assertions.assertTimeout;
public class MyTest {
@Test
public void testExecutionTime() {
assertTimeout(Duration.ofSeconds(5), () -> {
// Code block that should execute within 5 seconds
Thread.sleep(3000); // Simulating a time-consuming operation
});
}
}

In this example, the test method testExecutionTime verifies that the code block completes execution within 5 seconds. If the code block takes longer than 5 seconds to execute, the test will fail.

Here are some commonly used assertion methods:

1. assertEquals(expected, actual): This method checks if the expected value is equal to the actual value.

2. assertNotEquals(expected, actual): This method checks if the expected value is not equal to the actual value.

3. assertTrue(condition): This method checks if the specified condition evaluates to true.

4. assertFalse(condition): This method checks if the specified condition evaluates to false.

5. assertNull(object): This method checks if the specified object is null.

6. assertNotNull(object): This method checks if the specified object is not null.

7. assertSame(expected, actual): This method checks if the expected and actual objects refer to the same object instance.

8. assertNotSame(expected, actual): This method checks if the expected and actual objects do not refer to the same object instance.

@SpringBootTest -> Itis commonly used for integration testing. This annotation loads the complete application context and allows you to test your Spring Boot application in a real environment. You can use it to test controllers, services, repositories, and other components in your application. All our beans reside within the Spring Application Context. In our test classes, if we use the @Autowired annotation to inject dependencies but forget to include it, we won’t receive the instance we need, resulting in a NullPointerException due to being in a separate context. However, by adding the @SpringBootTest annotation, our tests will run after all the instances are created, ensuring proper dependency injection and preventing such exceptions.

contextLoad : The contextLoad method, sometimes referred to as the loadContext method, is a part of the testing lifecycle where the Spring context is created and initialized. This method ensures that all the necessary components of your application are loaded and configured correctly before running the test cases. If all resource is not loaded then it will kill the application

During integration testing, contextLoad ensures that your application’s dependencies are injected properly, beans are instantiated, and configurations are applied as they would be in a real-world scenario. This allows you to test your Spring Boot application in a simulated environment that closely resembles its actual runtime behavior.