Java 在我的存储库中使用@Query的MockMVC，或者重构我的控制器以不使用它？

我的存储库中有一个@Query，我基于SQL查询将数据返回给我的控制器，我将如何模拟它

这是我的存储库

package movieweb.movies.repository;

import movieweb.movies.models.UserMovies;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserMoviesRepository extends CrudRepository<UserMovies, Integer> {

    @Query(value = "select * from movies, user_movies where movies.movie_id = user_movies.movie_id and uname = ?1", nativeQuery = true)
    List<UserMovies> findByUname(String uname);
}

打包movieweb.movies.repository；
导入movieweb.movies.models.UserMovies；
导入org.springframework.data.jpa.repository.Query；
导入org.springframework.data.repository.crudepository；
导入org.springframework.stereotype.Repository；
导入java.util.List；
@存储库
公共接口UserMoviesRepository扩展了Crudepository{
@查询（value=“select*from movies，user\u movies，其中movies.movie\u id=user\u movies.movie\u id，uname=？1”，nativeQuery=true）
列表findByUname（字符串uname）；
}

这是我的控制器

package movieweb.movies.controllers;

import movieweb.movies.models.Movies;
import movieweb.movies.models.UserMovies;
import movieweb.movies.repository.UserMoviesRepository;
import org.apache.catalina.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.repository.Query;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class UserMoviesController {

    @Autowired
    private UserMoviesRepository umRepository;

    @CrossOrigin
    @PostMapping(path = "/newUserMovie")
    public ResponseEntity<UserMovies> addNewUserMovie(@RequestBody UserMovies data){
          umRepository.save(data);
        return new ResponseEntity<UserMovies>(data, HttpStatus.CREATED);

    }

    @CrossOrigin
    @GetMapping(path="/getUserMovies")
    public  List<UserMovies> getUsersMovies(){
        return (List<UserMovies>) umRepository.findAll();
    }

    @CrossOrigin
    @GetMapping(path = "/getUserMovies/{uname}")
    public  List<UserMovies> getUserMovies(@PathVariable String uname){
        return umRepository.findByUname(uname);
    }

    @CrossOrigin
    @DeleteMapping(path ="/deleteUserMovies/{id}")
    ResponseEntity deleteUserMovie(@PathVariable Integer id) {
        umRepository.deleteById(id);
        return new ResponseEntity(HttpStatus.ACCEPTED);
    }

    @CrossOrigin
    @PutMapping("/usermovie/update/{id}")
    public ResponseEntity<UserMovies> updateMovie(@RequestBody UserMovies updateMovie, @PathVariable Integer id) {
       return umRepository.findById(id)
                .map(userMovies -> {
                    userMovies.setMovieId(updateMovie.getMovieId());
                    userMovies.setUname(updateMovie.getUname());
                     umRepository.save(userMovies);
                    return new ResponseEntity<UserMovies>(userMovies, HttpStatus.OK);

                })
                .orElseGet(() -> {
                    updateMovie.setMovieId(id);
                     umRepository.save(updateMovie);
                    return new ResponseEntity<UserMovies>(updateMovie, HttpStatus.OK);
                });
    }

}

打包movieweb.movies.controllers；
导入movieweb.movies.models.movies；
导入movieweb.movies.models.UserMovies；
导入movieweb.movies.repository.UserMoviesRepository；
导入org.apache.catalina.User；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.data.jpa.repository.Query；
导入org.springframework.http.HttpStatus；
导入org.springframework.http.ResponseEntity；
导入org.springframework.web.bind.annotation.*；
导入java.util.List；
@RestController
公共类UserMoviesController{
@自动连线
私有用户moviesrepository；
@交叉起源
@PostMapping（path=“/newUserMovie”）
public ResponseEntity addNewUserMovie（@RequestBody UserMovies数据）{
umRepository.save（数据）；
返回新的响应属性（数据，HttpStatus.CREATED）；
}
@交叉起源
@GetMapping（路径=“/getUserMovies”）
公共列表getUsersMovies（）{
return（List）umRepository.findAll（）；
}
@交叉起源
@GetMapping（path=“/getUserMovies/{uname}”）
公共列表getUserMovies（@PathVariable字符串uname）{
返回umRepository.findByUname（uname）；
}
@交叉起源
@DeleteMapping（path=“/deleteUserMovies/{id}”）
ResponseEntity deleteUserMovie（@PathVariable整数id）{
umRepository.deleteById（id）；
返回新的响应状态（HttpStatus.ACCEPTED）；
}
@交叉起源
@PutMapping（“/usermovie/update/{id}”）
公共响应属性updateMovie（@RequestBody UserMovies updateMovie，@PathVariable整数id）{
返回umRepository.findById（id）
.map（userMovies->{
userMovies.setMovieId（updateMovie.getMovieId（））；
userMovies.setUname（updateMovie.getUname（））；
umRepository.save（userMovies）；
返回新的ResponseEntity（userMovies，HttpStatus.OK）；
})
.orElseGet（（）->{
updateMovie.setMovieId（id）；
umRepository.save（updateMovie）；
返回新的ResponseEntity（updateMovie，HttpStatus.OK）；
});
}
}

下面是我在测试中要做的

@Test
    void getUserMoviesPerUser() throws Exception{
        ArrayList<UserMovies> userMovies = new ArrayList<>();
        userMovies.add(new UserMovies(1, "jamie", 1));
        userMovies.add(new UserMovies(2, "joe", 1));
        userMovies.add(new UserMovies(3, "jamie", 2));
        userMovies.add(new UserMovies(4, "joe", 2));

        when(userMoviesRepository.findByUname("jamie")).thenReturn(userMovies);
        mockMvc.perform(get("/getUserMovies/{uname}", "jamie"))
                .andDo(print())
                .andExpect(jsonPath("$", hasSize(2)))
                .andExpect(jsonPath("$[0].userMovieID", is(1)))
                .andExpect(jsonPath("$[0].uname", is("jamie")))
                .andExpect(jsonPath("$[0].movieId", is(1)))
                .andExpect(jsonPath("$[1].userMovieID", is(3)))
                .andExpect(jsonPath("$[1].uname", is("jamie")))
                .andExpect(jsonPath("$[1].movieId", is(1)));

        Mockito.verify(userMoviesRepository, times(1)).findAll();
    }

@测试
void getUserMoviesPerUser（）引发异常{
ArrayList userMovies=新建ArrayList（）；
添加（新的userMovies（1，“jamie”，1））；
添加（新的userMovies（2，“joe”，1））；
添加（新的userMovies（3，“jamie”，2））；
添加（新的userMovies（4，“joe”，2））；
when（userMoviesRepository.findByUname（“jamie”）），然后return（userMovies）；
perform（get（“/getUserMovies/{uname}”，“jamie”））
.andDo（print（））
.andExpect（jsonPath（“$”，hasSize（2）））
.andExpect（jsonPath（“$[0].userMovieID”是（1）））
.andExpect（jsonPath（“$[0].uname”，是（“jamie”））
.andExpect（jsonPath（“$[0].movieId”，是（1）））
.andExpect（jsonPath（“$[1].userMovieID”是（3）））
.andExpect（jsonPath（“$[1].uname”，是（“jamie”））
.andExpect（jsonPath（“$[1].movieId”）是（1））；
verify（userMoviesRepository，times（1））.findAll（）；
}

---

我面临的问题是，当我运行上面的测试时，我并没有像我预期的那样只返回2条记录，而是返回4条记录。这是有道理的，因为我不能依赖SQL来运行测试。有没有更好的方法来编写我的控制器，以便根据电影id获取数据？

我认为您需要返回您期望的唯一记录。像

@Test
    void getUserMoviesPerUser() throws Exception{
        ArrayList<UserMovies> userMovies = new ArrayList<>();
        userMovies.add(new UserMovies(1, "jamie", 1));
        userMovies.add(new UserMovies(3, "jamie", 2));

        when(userMoviesRepository.findByUname("jamie")).thenReturn(userMovies);
        mockMvc.perform(get("/getUserMovies/{uname}", "jamie"))
                .andDo(print())
                .andExpect(jsonPath("$", hasSize(2)))
                .andExpect(jsonPath("$[0].userMovieID", is(1)))
                .andExpect(jsonPath("$[0].uname", is("jamie")))
                .andExpect(jsonPath("$[0].movieId", is(1)))
                .andExpect(jsonPath("$[1].userMovieID", is(3)))
                .andExpect(jsonPath("$[1].uname", is("jamie")))
                .andExpect(jsonPath("$[1].movieId", is(1)));

        Mockito.verify(userMoviesRepository, times(1)).findAll();
    }

@测试
void getUserMoviesPerUser（）引发异常{
ArrayList userMovies=新建ArrayList（）；
添加（新的userMovies（1，“jamie”，1））；
添加（新的userMovies（3，“jamie”，2））；
when（userMoviesRepository.findByUname（“jamie”）），然后return（userMovies）；
perform（get（“/getUserMovies/{uname}”，“jamie”））
.andDo（print（））
.andExpect（jsonPath（“$”，hasSize（2）））
.andExpect（jsonPath（“$[0].userMovieID”是（1）））
.andExpect（jsonPath（“$[0].uname”，是（“jamie”））
.andExpect（jsonPath（“$[0].movieId”，是（1）））
.andExpect（jsonPath（“$[1].userMovieID”是（3）））
.andExpect（jsonPath（“$[1].uname”，是（“jamie”））
.andExpect（jsonPath（“$[1].movieId”）是（1））；
verify（userMoviesRepository，times（1））.findAll（）；
}

在您的代码中，您正在为模拟创建

4条记录

，然后只需删除其中的

2条

，这样您就有

2条记录

作为响应

@Test
void getUserMoviesPerUser() throws Exception{
    ArrayList<UserMovies> userMovies = new ArrayList<>();
    userMovies.add(new UserMovies(1, "jamie", 1));
    userMovies.add(new UserMovies(2, "joe", 1));

    when(userMoviesRepository.findByUname("jamie")).thenReturn(userMovies);
    mockMvc.perform(get("/getUserMovies/{uname}", "jamie"))
            .andDo(print())
            .andExpect(jsonPath("$", hasSize(2)))
            .andExpect(jsonPath("$[0].userMovieID", is(1)))
            .andExpect(jsonPath("$[0].uname", is("jamie")))
            .andExpect(jsonPath("$[0].movieId", is(1)))
            .andExpect(jsonPath("$[1].userMovieID", is(3)))
            .andExpect(jsonPath("$[1].uname", is("jamie")))
            .andExpect(jsonPath("$[1].movieId", is(1)));

    Mockito.verify(userMoviesRepository, times(1)).findAll();
}

@测试
void getUserMoviesPerUser（）引发异常{
ArrayList userMovies=新建ArrayList（）；
添加（新的userMovies（1，“jamie”，1））；
添加（新的userMovies（2，“joe”，1））；
when（userMoviesRepository.findByUname（“jamie”）），然后return（userMovies）；
perform（get（“/getUserMovies/{uname}”，“jamie”））
.andDo（print（））
.andExpect（jsonPath（“$”，hasSize（2）））
.andExpect（jsonPath（“$[0].userMovieID”是（1）））
.andExpect（jsonPath（“$[0].uname”，是（“jamie”））
.andExpe