Prime 20 Spring Framework Testing Interview Questions Solutions for two to five Years Skilled

@RunWith(SpringRunner.class)
@ContextConfiguration(lessons = BookConfiguration.class)
public class BookBorrowServiceJUnit4ContextTests implements ApplicationContextAware {
   
}

6. When and the place do you utilize @Transactional in testing?
If you happen to bear in mind, the
@Transactional annotation
defines the scope of a single database transaction and a database
transaction occurs contained in the scope of a persistence context. On testing,
you should use
@Transaction annotation at each
strategies and sophistication ranges.

On the technique degree, the annotated take a look at technique(s) will run, every in its
personal transaction. By default, robotically rolled again after completion of
the take a look at. You may also alter this habits by disabling the
defaultRollback attribute of
@TransactionConfiguration.

You may also use
@Transactional on the class
degree and in that case, every take a look at technique inside that class hierarchy runs
inside a transaction. 

7. How is @ContextConfiguration utilized in Spring Boot?
The @ContextConfiguration is an
essential annotation for Spring Boot testing. It’s a class-level
annotation that’s used to load the appliance context for the
integration take a look at. That is outlined within the spring-test module.

Right here is an instance of
@ContextConfiguration in Spring
Boot assessments

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(lessons=BookConfiguration.class)
public class BookServiceTest {

  @Autowired 
  non-public BookService bookService;

  @Take a look at public void testBookService() {
   Ebook aBook = bookService.findByTitle("Spring Boot in Motion");
   assertEquals("Craig Partitions", aBook.getAuthor());
   assertEquals(40, aBook.getPrice());
  }


}

This instance, it makes use of
BookConfiguration class to
create an utility context and cargo bean definitions. if
@ContextConfiguration
is used with none attributes outlined, the default habits of spring
boot is to seek for a file named
{testClassName}-context.xml in
the identical location because the take a look at class and cargo bean definitions from there
if discovered.

Spring Boot additionally gives
@SpringBootTest annotation,
which can be utilized as an alternative choice to the usual spring-test
@ContextConfiguration
annotation while you want Spring Boot options.

You’ll be able to
use Mockito within the Spring boot utility utilizing both by @RunWith(MockitoJUnitRunner.class) to initialize the mock objects or through the use of MockitoAnnotations.initMocks(this) within the JUnit @Earlier than technique.

You may also use @MockBean annotation supplied by Spring Boot which can be utilized to outline a
new Mockito mock bean or substitute a Spring bean with a mock bean and inject
that into their dependent beans. One other advantage of that is that If
your take a look at makes use of one among Spring Boot’s take a look at annotations (corresponding to @SpringBootTest), this characteristic is robotically enabled.

9. How does Spring Boot simplify writing assessments?
Spring boot gives a starter dependency spring-boot-starter-test which
hundreds all-important testing libraries. 

• JUnit: customary library for writing unit assessments in Java
• JSON Path: XPath for JSON
• AssertJ: Fluent assertion library
• Mockito: Java mocking library
• Hamcrest: Library of matcher objects
• JSONassert: Assertion library for JSON
• Spring Take a look at and Spring Boot Take a look at: These are the take a look at libraries
  supplied by the Spring Framework and Spring Boot.

Spring Boot additionally gives a
@SpringBootTest annotation,
which can be utilized as an alternative choice to the usual spring-test
@ContextConfiguration annotation while you want
Spring Boot options.

10. What does @SpringBootTest do? How does it work together with
@SpringBootApplication and @SpringBootConfiguration?
The @SpringBootTest annotation
tells Spring Boot to search for the primary configuration class (the one with
@SpringBootApplication, for
occasion) and use that to begin a Spring utility context.

11. When do you wish to use @SpringBootTest annotation?
You should utilize
@SpringBootTest annotation
everytime you wish to take a look at your Spring boot utility. For instance, you
can use @SpringBootTest to
confirm if the context is loaded or not and if the context is creating your
controller or not.

right here is an instance of utilizing
@SpringBootTest annotation to
verify

import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Take a look at;
import org.springframework.beans.manufacturing facility.annotation.Autowired;
import org.springframework.boot.take a look at.context.SpringBootTest;

@SpringBootTest
public class CheckControllerTest {
  @Autowired
  non-public BookController controller;
  
  @Take a look at
   public void contextLoads() throws Exception {
       assertThat(controller).isNotNull();
   }
}

You’ll be able to see we’re verifying if the controller is created or not
utilizing AssertJ strategies.

12. What does @SpringBootTest auto-configure?
Spring Boot gives the
@SpringBootTest annotation,
which can be utilized as an alternative choice to the usual spring-test
@ContextConfiguration
annotation while you want Spring Boot options. The annotation works by
creating the
ApplicationContext utilized in your
assessments via SpringApplication identical to
@SpringApplicaitonConfiguration
does. 

13. What dependencies does the spring-boot-starter-test brings to the
classpath?
The spring-boot-starter-test provides the next helpful testing libraries
into classpath:

• JUnit 4: The de-facto customary for unit testing Java functions.
• Spring Take a look at & Spring Boot Take a look at: Utilities and integration take a look at
  help for Spring Boot functions.
• AssertJ: A fluent assertion library.
• Hamcrest: A library of matcher objects (also called constraints or
  predicates).
• Mockito: A Java mocking framework.
• JSONassert: An assertion library for JSON.
• JsonPath: XPath for JSON.

You’ll usually discover these widespread libraries to be helpful when writing
assessments.

14. How do you carry out integration testing with @SpringBootTest for a
net utility?
You’ll be able to both use
@SpringBootTest to load full
context for integration take a look at or you should use
@WebMvcTest to solely load the
net layer excited by loading the entire context.

15. When do you wish to use @WebMvcTest? What does it auto-configure?
You should utilize
@WebMvcTest annotation for
testing the net layer of your Spring Boot utility. Whenever you use
@WebMvcTest as an alternative of
@SpringBootTest then Spring
Boot solely instantiates the net layer relatively than the entire context.

16. What are the variations between @MockBean and @Mock annotations?
Each @Mock and
@MockBean are used extensively
whereas writing unit assessments in Java and Spring functions. It’s best to use
@Mock when unit testing your
enterprise logic impartial of the Spring framework, you are able to do this by
utilizing solely utilizing JUnit and Mockito and use
@MockBean while you write a take a look at
that’s backed by a Spring Take a look at Contexts and also you wish to add or substitute a
bean with a mocked model of it

17. When would you like @DataJpaTest for? What does it auto-configure?
You should utilize @DataJpaTest annotation to arrange an atmosphere with an
embedded database to check your database queries towards. That is one among
the handy options Spring boot gives to simplify testing. 

Right here is an instance of
@DataJpaTest
annotation within the Spring Boot utility:

@ExtendWith(SpringExtension.class)
@DataJpaTest

public class OrderEntityRepositoryTest {

  @Autowired 
  non-public DataSource dataSource;
  @Autowired 
  non-public JdbcTemplate jdbcTemplate;
  @Autowired 
  non-public EntityManager entityManager;
  @Autowired 
  non-public OrderRepository orderRepository;


  @Take a look at
  public void injectedComponentsAreNotNull(){
   assertThat(dataSource).isNotNull();
   assertThat(jdbcTemplate).isNotNull();
   assertThat(entityManager).isNotNull();
   assertThat(orderRepository).isNotNull();
 }
}

Btw, these code examples use the
@ExtendWith annotation to inform
JUnit 5 to allow Spring help. however from Spring Boot 2.1, you do not want
to load the SpringExtension as a result of it is robotically included as a
meta-annotation within the Spring Boot take a look at annotations like
@DataJpaTest,
@WebMvcTest, and
@SpringBootTest. 

18. What’s using
@DirtiesContext annotation
whereas Testing Spring Boot utility?
One of many good options of Spring Take a look at help is that the appliance
context is cached between assessments. That method, when you’ve got a number of strategies in
a take a look at case or a number of take a look at instances with the identical configuration, they incur
the price of beginning the appliance solely as soon as. You’ll be able to management the cache
through the use of the
@DirtiesContext
annotation.

19. What’s the distinction between
@ContextConfiguration and
@SpringApplicatoinConfiguration
in Spring Boot testing?
Whereas each @ContextConfiguration and
@SpringApplicatoinConfiguration
annotations can be utilized to load utility context for spring boot
testing, there’s a refined distinction between them. 

Briefly, it is higher to make use of the
@SpringApplicatoinConfiguration
annotations relatively than
@ContextConfiguration for
writing an integration take a look at for the Spring boot utility.

20. What’s the distinction between @ContextConfiguration and
@SpringBootTest?
This query can be similar to the earlier query. In contrast to the
@ContextConfiguration which
simply hundreds spring beans and creates utility context for testing
with out utilizing spring boot options, the
@SpringBootTest annotation makes use of
SpringApplication behind the scenes to load ApplicationContext so that every one
the Spring Boot options might be out there.

That is all about
Spring Boot Testing Interview Questions and Solutions for Java
builders. This text not solely covers spring boot-specific testing questions however
additionally common Spring framework testing questions. It additionally solutions all of the
testing-related questions that you’ll find within the official Spring
Certification Examination information, therefore in case you are making ready for spring
certification, you can even refer to those solutions to enhance your
information about this essential matter.