1. Is it right to use @SpringBootTest (or) @ContextConfiguration in Unit Test?
   Starting spring for each test is a very expensive operation. It’s not a unit test anymore rather integration test. @SpringBootTest goes further and tries to mimic the processes added by Spring Boot framework for creating the context: Decides what to scan based on package structures, loads external configurations from predefined locations optionally runs autoconfiguration starters and so on and so forth. @SpringBootTest loads the necessary beans and inject into each other.
   When using @ContextConfiguration you present way to filter what exactly should be run, what beans to load and to inject into each other.
2. How to Optimize the Unit test by selectively loading the resource?
   You can selectively load the resource during unit test
   • To test your Respository : use @DataJpaTest annotation for test slice.
   • To test your Service layer : use JUnit and Mockito. Here you will mock your Repository
   • To test your Controller layer : use @WebMvcTest annotation for test slice or use JUnit and Mockito. Here you will mock your Service in both cases
   • To test a Component, such as a third party library wrapper or load some specific beans: use @ExtendWith(SpringExtension.class) and @ContextConfiguration/@Import or @SpringJUnitWebConfig which is the combinaison of the both.
   • To do an integration test : use @SpringBootTest
3. When to use @SpringBootTest and @ExtendWith(SpringExtension.class)
   Use @ExtendWith(SpringExtension.class) without loading the entire application context that is included with @SpringBootTest. As you say it’s a lighter weight approach if you just want to mock beans with @MockBean. @SpringBootTest does in fact include @ExtendWith(SpringExtension.class)

   Use @SpringBootTest when,

   • You need to test the application as a whole, including multiple layers like the web layer, service layer, and repository layer.
   • You require an embedded server to run the test, such as when testing web controllers.
   • You want to verify the integration of all components in a fully loaded application context.

   Use SpringRunner/@ExtendWith(SpringExtension.class) when,

   • You are writing unit tests or lightweight integration tests that only need certain features of Spring, such as dependency injection or transaction management, without loading the full application context.
   • You want to test specific layers (e.g., service layer) in isolation without the overhead of starting the entire Spring application.

BaseUnitTest.java

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;

import java.util.concurrent.TimeUnit;

public class BaseUnitTest {
    long startTime;
    long endTime;

    @BeforeEach
    public void recordStartTime() {
        startTime = System.currentTimeMillis();
    }

    @AfterEach
    public void recordEndAndExecutionTime() {
        endTime = System.currentTimeMillis();
        System.out.println("Last testcase exection time in millisecond : " + 
                              TimeUnit.NANOSECONDS.toMicros((endTime - startTime)) + " Seconds");
    }
}

FirstTest.java

import org.junit.jupiter.api.Test;

class FirstTest extends BaseUnitTest{
    @Test
    void oneSecondTest() throws InterruptedException {
        System.out.println("oneSecondTest() name  =>  " + Thread.currentThread().getName());
        Thread.sleep(1000);
    }

    @Test
    void twoSecondTest() throws InterruptedException {
        System.out.println("twoSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(2000);
    }

    @Test
    void threeSecondTest() throws InterruptedException {
        System.out.println("threeSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(3000);
    }
}

SecondTest.java

import org.junit.jupiter.api.Test;

public class SecondTest extends BaseUnitTest{
    @Test
    void oneSecondTest() throws InterruptedException {
        System.out.println("oneSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(1000);
    }

    @Test
    void twoSecondTest() throws InterruptedException {
        System.out.println("twoSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(2000);
    }

    @Test
    void threeSecondTest() throws InterruptedException {
        System.out.println("threeSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(3000);
    }
}

ThirdTest.java

import org.junit.jupiter.api.Test;

public class ThirdTest extends BaseUnitTest{
    @Test
    void oneSecondTest() throws InterruptedException {
        System.out.println("oneSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(1000);
    }

    @Test
    void twoSecondTest() throws InterruptedException {
        System.out.println("twoSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(2000);
    }

    @Test
    void threeSecondTest() throws InterruptedException {
        System.out.println("threeSecondTest() name => " + Thread.currentThread().getName());
        Thread.sleep(3000);
    }
}

Output

Last testcase exection time in millisecond : 0 Seconds
Last testcase exection time in millisecond : 2 Seconds
Last testcase exection time in millisecond : 2 Seconds
Last testcase exection time in millisecond : 2 Seconds
Last testcase exection time in millisecond : 3 Seconds
Last testcase exection time in millisecond : 3 Seconds
Last testcase exection time in millisecond : 3 Seconds
threeSecondTest() name => ForkJoinPool-1-worker-10
twoSecondTest() name => ForkJoinPool-1-worker-7
oneSecondTest() name  =>  ForkJoinPool-1-worker-1
twoSecondTest() name => ForkJoinPool-1-worker-6
oneSecondTest() name => ForkJoinPool-1-worker-3
threeSecondTest() name => ForkJoinPool-1-worker-5
oneSecondTest() name => ForkJoinPool-1-worker-4
twoSecondTest() name => ForkJoinPool-1-worker-8
threeSecondTest() name => ForkJoinPool-1-worker-9

junit-platform.properties

# Enable parallelism
junit.jupiter.execution.parallel.enabled = true

# Enable parallelism for both test methods and classes
junit.jupiter.execution.parallel.mode.default =  concurrent

In Maven Command

>>mvn test -Djunit.jupiter.execution.parallel.enabled=true  -Djunit.jupiter.execution.parallel.mode.default=concurrent

Four possibilities in junit-platform.properties config

//Only One class and One method in that class would be executed - Sequential Execution
junit.jupiter.execution.parallel.mode.default =  same_thread
junit.jupiter.execution.parallel.mode.classes.default = same_thread

//More than one class would run in parallel but only one method in each class would be executed 
//Test method within one class run sequentially but more than one class run in parallel
junit.jupiter.execution.parallel.mode.default =  same_thread
junit.jupiter.execution.parallel.mode.classes.default = concurrent

//Only One class and Multiple method in that class would be executed
junit.jupiter.execution.parallel.mode.default =  concurrent
junit.jupiter.execution.parallel.mode.classes.default = same_thread

//Multiple classes and Multiple method in  those classes would be executed
junit.jupiter.execution.parallel.mode.default =  concurrent
junit.jupiter.execution.parallel.mode.classes.default = concurrent