Java 预期状态：<；200>；但事实是：<；404>；弹簧试验

我有这门课：

    package controllers;

    import static org.junit.Assert.*;
    import static org.mockito.Mockito.mock;
    import static org.mockito.Mockito.times;
    import static org.mockito.Mockito.verify;
    import static org.mockito.Mockito.when;

    import java.util.HashSet;

    import org.junit.Before;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.mockito.InjectMocks;
    import org.mockito.Mock;
    import org.mockito.MockitoAnnotations;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;


    import org.springframework.ui.Model;
    import org.springframework.web.context.WebApplicationContext;

    import com.epam.hhsystem.model.candidate.Candidate;
    import com.epam.hhsystem.services.CandidateService;
    import com.epam.hhsystem.web.controllers.CandidateMenuController;
    import org.springframework.test.context.web.WebAppConfiguration;
    import org.springframework.test.context.junit4.*;
    import org.springframework.test.web.servlet.MockMvc;
    import org.springframework.test.web.servlet.ResultActions;
    import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
    import org.springframework.test.web.servlet.setup.MockMvcBuilders;


    import org.springframework.test.web.servlet.request.*;

    import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
    import static org.hamcrest.Matchers.*;
    import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
    import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;


    @ContextConfiguration(locations = { "classpath:/test/BeanConfig.xml" })
    @RunWith(SpringJUnit4ClassRunner.class)
    @WebAppConfiguration
    public class CandidateControllerTest {

        @Mock(name = "candidateService")
        private CandidateService candidateService;

        @InjectMocks
        private CandidateMenuController candidateMenuController = new CandidateMenuController();

        @Autowired
        WebApplicationContext wac;

        MockMvc mockMvc;

        @Before
        public void before() {
            MockitoAnnotations.initMocks(this);
              this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).dispatchOptions(true).build();

        }
@Test 
    public void testgoToCandidateMenuMockMvc() throws Exception { 
        //MockHttpServletRequestBuilder request = MockMvcRequestBuilders.get("/goToCandidateMenu");


        MockHttpServletRequestBuilder request = MockMvcRequestBuilders.get("/goToCandidateMenu");
        ResultActions result = mockMvc.perform(request);
        result.andExpect(status().isOk());
     }
}

当我执行它时，我看到：

java.lang.AssertionError: Status expected:<200> but was:<404>
at org.springframework.test.util.AssertionErrors.fail(AssertionErrors.java:60)
at org.springframework.test.util.AssertionErrors.assertEquals(AssertionErrors.java:89)
at org.springframework.test.web.servlet.result.StatusResultMatchers$5.match(StatusResultMatchers.java:549)
at org.springframework.test.web.servlet.MockMvc$1.andExpect(MockMvc.java:141)
at controllers.CandidateControllerTest.testgoToCandidateMenuMockMvc(CandidateControllerTest.java:104)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:74)
at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:83)
at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:72)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:88)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71)
at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

你能帮我解决我的问题吗

更新

BeanConfig.xml：

 <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:jee="http://www.springframework.org/schema/jee" xmlns:lang="http://www.springframework.org/schema/lang"
        xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:util="http://www.springframework.org/schema/util"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
            http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

        <!-- Включаем опцию использования конфигурационных аннотаций (@Annotation-based configuration)-->
        <context:annotation-config />


        <context:component-scan base-package="com.epam.hhsystem.jpa" />
        <context:component-scan base-package="com.epam.hhsystem.services" />

        <!-- Файл с настройками ресурсов для работы с данными (Data Access Resources) -->
        <import resource="data.xml" />

    </beans>

data.xml

<?xml  version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:lang="http://www.springframework.org/schema/lang"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
        http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

<!-- Настраивает управление транзакциями с помощью аннотации @Transactional -->
    <tx:annotation-driven transaction-manager="transactionManager" />

    <!-- Менеджер транзакций -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- Непосредственно бин dataSource -->
    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource"
        p:driverClassName="com.microsoft.sqlserver.jdbc.SQLServerDriver"
        p:url="jdbc:sqlserver://10.16.9.52:1433;databaseName=hhsystemTest;"
        p:username="userNew" 
        p:password="Pass12345" />

    <!-- Настройки фабрики сессий Хибернейта -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation">
            <value>classpath:test/hibernate.cfg.xml</value>
        </property>

        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
                <prop key="hibernate.connection.charSet">UTF-8</prop>
<!--                <prop key="hibernate.hbm2ddl.auto">create-drop</prop> -->
        </props>
        </property>
    </bean>

</beans>

类路径：test/hibernate.cfg.xml
真的
org.hibernate.dialogue.sqlserverdialogue
UTF-8

您的测试设置错误您没有正确初始化

MockMvc

，这在参考指南中有明确说明。首先，您有两次初始化代码，并且您没有对

build

方法调用的结果进行赋值。因此，基本上只剩下一个空的

MockMvc

对象

@Before
public void before() {
    MockitoAnnotations.initMocks(this);
    MockMvcBuilders.webAppContextSetup(this.wac).dispatchOptions(true).build();
    MockMvcBuilders.webAppContextSetup(this.wac).dispatchOptions(true).build();
}

应该是

@Before
public void before() {
    MockitoAnnotations.initMocks(this);
    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).dispatchOptions(true).build();
}

---

如前所述，这些都在中进行了解释。

我相信您只是没有在

beanconfig.xml

中启用

，因此您的

@Controller

类没有注册

加上这个

<mvc:annotation-driven></mvc:annotation-driven>

---

我将此注释添加到配置类并使用它：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader = AnnotationConfigWebContextLoader.class)
@WebAppConfiguration
public class ResourceTest {

   ...

   @Configuration
   @EnableWebMvc
   @ComponentScan( basePackages = { "..." } )
   static class ContextConfiguration {
   }
}

---

这是我的工作方案。希望能有帮助

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
@WebAppConfiguration
public class SimpleTest  {

private MockMvc mockMvc;

@Autowired
private WebApplicationContext webApplicationContext;

@Before
public void setup() throws Exception {
    mockMvc = webAppContextSetup(webApplicationContext)
            .build();
    }

@Test
public void test() throws Exception {        
    mockMvc.perform(get("/simple")
            .contentType(MediaType.APPLICATION_JSON))
            .andExpect(status().is(200));
    }
}

---

在我的例子中，我丢失了下面的注释，并且得到了这个错误

@WebMvcTest(UserStatsController.class)
public class UserStatsControllerTest {
  ..
}

请注意，控制器和的类不是测试。

---

如果您使用@ContextConfiguration（而不是test）加载其他类，请确保不要加载test类。

如果您像我一样犯了一个非常愚蠢的“为了自己好而快速”错误，请确保您的控制器测试类与控制器类本身没有相同的名称。大多数人都知道这一点，但您可能会遇到相同的错误情况，即名称相同，并且可能无法立即看出原因。为了进一步澄清，请确保您没有这样做：

控制器名称：

MyController

测试类名称：

MyController

这可能导致MockMvc测试失败，状态为404。。。这不是很明显。
命名[显然]应该更像：

控制器名称：

MyController

---

测试类名：

MyControllerTest

我的问题是我没有@ComponentScan（），这很尴尬。

---

也很难找到。我自己忽略了我的SpringBoot应用程序。

以下是我在SpringMVC中所做的工作，效果很好（解释为无法找到直接参考） 控制器类如下

            package rndpurpose.controller;

            @RestController
            @RequestMapping("/springmvc")
            public class urlController {

                @CrossOrigin
                @RequestMapping(value = "managepostReq", method = RequestMethod.POST, headers = "Accept=application/json")
                public Map<String, Object> managepostReq()
                {
                    Map<String, Object> response = new HashMap<>();

                    //System.out.println(data);
                    response.put("status", true);

                    return response;
                }
            }

和JunitAbstract来处理请求

            package rndpurpose.test;
            import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
            import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
            import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
            import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
            import java.lang.reflect.InvocationTargetException;
            import java.nio.charset.Charset;
            import org.junit.Before;
            import org.junit.runner.RunWith;
            import org.mockito.MockitoAnnotations;
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.context.annotation.ComponentScan;
            import org.springframework.http.MediaType;
            import org.springframework.mock.web.MockMultipartFile;
            import org.springframework.test.context.ContextConfiguration;
            import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
            import org.springframework.test.context.web.WebAppConfiguration;
            import org.springframework.test.web.servlet.MockMvc;
            import org.springframework.test.web.servlet.ResultActions;
            import org.springframework.test.web.servlet.request.MockMultipartHttpServletRequestBuilder;
            import org.springframework.test.web.servlet.setup.MockMvcBuilders;
            import org.springframework.util.MultiValueMap;
            import org.springframework.web.context.WebApplicationContext;
            import rndpurpose.config.WebConfig;
            @RunWith(SpringJUnit4ClassRunner.class)
            @ContextConfiguration(classes = WebConfig.class)
            @WebAppConfiguration
            @ComponentScan(basePackages="rndpurpose")
            public abstract class JunitAbstract {

                public static final MediaType APPLICATION_JSON_UTF8 = new MediaType(MediaType.APPLICATION_JSON.getType(), MediaType.APPLICATION_JSON.getSubtype(), Charset.forName("utf8"));

                private MockMvc mockMvc;

                @Autowired
                public WebApplicationContext wac;


                @Before
                public void setup() {
                    MockitoAnnotations.initMocks(this);
                    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
                }

                public ResultActions postRequest(String url, String bodyData) {
                    ResultActions resultActions = null;
                    try {
                        System.out.println(url);
                        resultActions = mockMvc.perform(post(url).contentType(MediaType.APPLICATION_JSON)
                                .accept(MediaType.APPLICATION_JSON).content(bodyData));
                                
                    }
                    
                    catch (InvocationTargetException e) {
                        e.getCause().printStackTrace();
                    } 
                    catch (Exception e) {
                        System.err.println("Error while executing post req "+ e);
                    }
                    return resultActions;
                }

                public ResultActions getRequest(String url) {
                    ResultActions resultActions = null;
                    try {
                        resultActions = this.mockMvc.perform(get(url)).andDo(print());
                    } catch (Exception e) {
                        System.err.println("Error while executing test case for get"+ e);
                    }
                    return resultActions;
                }

                public ResultActions multipartFileUpload(String url, MultiValueMap<String, String> bodyMap,
                        MockMultipartFile... files) {
                    ResultActions resultActions = null;
                    try {
                        MockMultipartHttpServletRequestBuilder builder = multipart(url);
                        addMultipartFiles(builder, files);
                        if (bodyMap != null)
                            builder.params(bodyMap);
                        resultActions = mockMvc.perform(builder);
                    } catch (Exception e) {
                        System.err.println("Error in multipartFileUpload "+ e);
                    }
                    return resultActions;
                }

                private void addMultipartFiles(MockMultipartHttpServletRequestBuilder builder, MockMultipartFile... files) {
                    if (files != null) {
                        for (MockMultipartFile file : files) {
                            builder.file(file);
                        }
                    }

                }

            }

包装rndpurpose.test；
导入静态org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get；
导入静态org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart；
导入静态org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post；
导入静态org.springframework.test.web.servlet.result.MockMvcResultHandlers.print；
导入java.lang.reflect.InvocationTargetException；
导入java.nio.charset.charset；
导入org.junit.Before；
导入org.junit.runner.RunWith；
导入org.mockito.MockitoAnnotations；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.context.annotation.ComponentScan；
导入org.springframework.http.MediaType；
导入org.springframework.mock.web.MockMultipartFile；
导入org.springframework.test.context.ContextConfiguration；
导入org.springframework.test.context.junit4.SpringJUnit4ClassRunner；
导入org.springframework.test.context.web.WebAppConfiguration；
导入org.springframework.test.web.servlet.MockMvc；
导入org.springframework.test.web.servlet.ResultActions；
导入org.springframework.test.web.servlet.request.mockmultipartttpServletRequestBuilder；
导入org.springframework.test.web.servlet.setup.MockMvcBuilders；
导入org.springframework.util.MultiValueMap；
导入org.springframework.web.context.WebApplicationContext；
导入rndpuse.config.WebConfig；
@RunWith（SpringJUnit4ClassRunner.class）
@ContextConfiguration（类=WebConfig.class）
@WebAppConfiguration
@组件扫描（basePackages=“rndpurpose”）
公共抽象类JunitAbstract{
public static final MediaType APPLICATION_JSON_UTF8=新的MediaType（MediaType.APPLICATION_JSON.getType（），MediaType.APPLICATION_JSON.getSubtype（），Charset.forName（“UTF8”）；
私有MockMvc-MockMvc；
@自动连线
公共Web应用程序上下文wac；
@以前
公共作废设置（）{
initMocks（this）；
this.mockMvc=MockMvcBuilders.webAppContextSetup（this.wac.build（）；
}
公共结果postRequest（字符串url、字符串bodyData）{
ResultActions ResultActions=null；
试一试{
System.out.println（url）；
resultActions=mockMvc.perform（post（url）.contentType（MediaType.APPLICATION_JSON）
.accept（MediaType.APPLICATION_JSON）.content（bodyData））；
}
捕获（调用TargetException e）{
e、 getCause（）.printStackTrace（）；
} 
捕获（例外e）{
System.err.println（“执行post req时出错”+e）；
}
返回结果；
}
公共结果getRequest（字符串
            package rndpurpose.test;

            import static org.hamcrest.Matchers.is;
            import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
            import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
            import org.json.JSONObject;
            import org.junit.Test;
            import org.springframework.core.annotation.Order;
            import org.springframework.test.web.servlet.MvcResult;
            import org.springframework.test.web.servlet.ResultActions;
            import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
            import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
            import junit.framework.Assert;

            public class UrlcontrollerTest extends JunitAbstract {

                @Test
                @Order(1)
                public void firsttestcase() throws Exception {
                /*jai ganesha*/
                    try {
                        JSONObject jsonGetData = new JSONObject();
                        jsonGetData.put("username", "name");
                        
                        ResultActions resultActions = postRequest("/springmvc/managepostReq", jsonGetData.toString());
                        MvcResult mvcResult = resultActions.andExpect(status().isOk())
                                .andDo(MockMvcResultHandlers.print())
                                .andReturn();

                        
                        JSONObject reqResponse = new JSONObject(mvcResult.getResponse().getContentAsString());
                        System.out.println(reqResponse);

                    } catch (Exception e) {
                        System.err.println("ERROR"+ e);
                    }
                }

            }

            package rndpurpose.test;
            import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
            import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
            import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
            import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
            import java.lang.reflect.InvocationTargetException;
            import java.nio.charset.Charset;
            import org.junit.Before;
            import org.junit.runner.RunWith;
            import org.mockito.MockitoAnnotations;
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.context.annotation.ComponentScan;
            import org.springframework.http.MediaType;
            import org.springframework.mock.web.MockMultipartFile;
            import org.springframework.test.context.ContextConfiguration;
            import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
            import org.springframework.test.context.web.WebAppConfiguration;
            import org.springframework.test.web.servlet.MockMvc;
            import org.springframework.test.web.servlet.ResultActions;
            import org.springframework.test.web.servlet.request.MockMultipartHttpServletRequestBuilder;
            import org.springframework.test.web.servlet.setup.MockMvcBuilders;
            import org.springframework.util.MultiValueMap;
            import org.springframework.web.context.WebApplicationContext;
            import rndpurpose.config.WebConfig;
            @RunWith(SpringJUnit4ClassRunner.class)
            @ContextConfiguration(classes = WebConfig.class)
            @WebAppConfiguration
            @ComponentScan(basePackages="rndpurpose")
            public abstract class JunitAbstract {

                public static final MediaType APPLICATION_JSON_UTF8 = new MediaType(MediaType.APPLICATION_JSON.getType(), MediaType.APPLICATION_JSON.getSubtype(), Charset.forName("utf8"));

                private MockMvc mockMvc;

                @Autowired
                public WebApplicationContext wac;


                @Before
                public void setup() {
                    MockitoAnnotations.initMocks(this);
                    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
                }

                public ResultActions postRequest(String url, String bodyData) {
                    ResultActions resultActions = null;
                    try {
                        System.out.println(url);
                        resultActions = mockMvc.perform(post(url).contentType(MediaType.APPLICATION_JSON)
                                .accept(MediaType.APPLICATION_JSON).content(bodyData));
                                
                    }
                    
                    catch (InvocationTargetException e) {
                        e.getCause().printStackTrace();
                    } 
                    catch (Exception e) {
                        System.err.println("Error while executing post req "+ e);
                    }
                    return resultActions;
                }

                public ResultActions getRequest(String url) {
                    ResultActions resultActions = null;
                    try {
                        resultActions = this.mockMvc.perform(get(url)).andDo(print());
                    } catch (Exception e) {
                        System.err.println("Error while executing test case for get"+ e);
                    }
                    return resultActions;
                }

                public ResultActions multipartFileUpload(String url, MultiValueMap<String, String> bodyMap,
                        MockMultipartFile... files) {
                    ResultActions resultActions = null;
                    try {
                        MockMultipartHttpServletRequestBuilder builder = multipart(url);
                        addMultipartFiles(builder, files);
                        if (bodyMap != null)
                            builder.params(bodyMap);
                        resultActions = mockMvc.perform(builder);
                    } catch (Exception e) {
                        System.err.println("Error in multipartFileUpload "+ e);
                    }
                    return resultActions;
                }

                private void addMultipartFiles(MockMultipartHttpServletRequestBuilder builder, MockMultipartFile... files) {
                    if (files != null) {
                        for (MockMultipartFile file : files) {
                            builder.file(file);
                        }
                    }

                }

            }

    <!-- test starts -->


    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.1.2.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>


    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-junit-jupiter</artifactId>
        <version>2.23.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.platform</groupId>
        <artifactId>junit-platform-runner</artifactId>
        <version>1.2.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.assertj</groupId>
        <artifactId>assertj-core</artifactId>
        <version>3.8.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.hamcrest</groupId>
        <artifactId>hamcrest-all</artifactId>
        <version>1.3</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>1.10.19</version>
        <exclusions>
            <exclusion>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest-core</artifactId>
            </exclusion>
        </exclusions>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.jayway.jsonpath</groupId>
        <artifactId>json-path</artifactId>
        <version>2.0.0</version>
    </dependency>

    <!-- test ends -->

@EnableWebMvc
public class WebConfig  {

private static final Logger LOGGER = Logger.getLogger(WebConfig.class);

@Bean
public CommonsMultipartResolver multipartResolver() {
    final CommonsMultipartResolver resolver = new CommonsMultipartResolver();
    resolver.setMaxUploadSize(20971520);
    resolver.setMaxInMemorySize(1048576);
    return resolver;
}
@Bean
public DataSource dataSource() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    
     dataSource.setUrl("jdbc:postgresql://192.168.2.29:5432/trintiygisenterprise");
     dataSource.setDriverClassName("org.postgresql.Driver");
     dataSource.setUsername("postgres"); 
     dataSource.setPassword("track@123");
     
    return dataSource;
}

@Bean
public Connection getConnectionObject() {
    Connection con  = null;
    try {
        Class.forName("org.postgresql.Driver");

         con = DriverManager.getConnection("jdbc:postgresql://localhost:5432/t26",
                 "postgres", "track@123");

         System.out.println("====================CONNECTED TO DB================ "+con);
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println(e);
    }
    return con;

}

@Bean
@Autowired
public JdbcTemplate jdbcTemplate(DataSource dataSource) {

    return new JdbcTemplate(dataSource);
}
}

<context:component-scan base-package="com" />
 <mvc:annotation-driven />  
<!--  <mvc:resources mapping="/*" location="/" />-->

<mvc:default-servlet-handler/>
<bean class="com.config.WebConfig"/>
</beans>

    <servlet>
    <servlet-name>springrest</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>springrest</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

@RestController
@RequestMapping("/api")
public class bootsrapController {


/**
@GetMapping("/second")
**/
@RequestMapping(value = "second", method = RequestMethod.GET, headers = 
"Accept=application/json")
public Map<String, Object> second() 
{
    Map<String, Object> result = new HashMap<>();
    result.put("second", true);
    result.put("status", true);
return result;
}
}

public class UrlcontrollerTest extends JunitAbstract {
    @Test
@Order(1)
public void unittestcreatelayergroup(){

    try {

        System.out.println("Running test");
        
        final ResultActions resultActions = getRequest("/api/second");
        System.out.println(resultActions);
        
        final MvcResult mvcResult = resultActions
                .andDo(MockMvcResultHandlers.print())
                .andExpect(status().isOk())
                .andExpect(jsonPath("status", is(true)))
                .andReturn(); 
}
    catch (final Exception e) {

        LOGGER.error(e.getStackTrace());

    }
}

@ContextConfiguration("file:src/main/webapp/WEB-INF/springrest-servlet.xml") 
@WebAppConfiguration
public abstract class JunitAbstract {

private static final Logger LOGGER = Logger.getLogger(JunitAbstract.class);

private MockMvc mockMvc;

@Autowired
public WebApplicationContext wac;

@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
}

public ResultActions getRequest(String url) {
    LOGGER.info("sending req--------: "+url);

    ResultActions resultActions = null;
    try {
        resultActions = this.mockMvc.perform(get(url)).andDo(print());
    } catch (Exception e) {
        LOGGER.error("Error while executing test case for get"+ e);
    }
    return resultActions;
}