Se moquer d'une méthode vide dans le cadre de printemps (Makito)

Je suis en train d'écrire des tests d'intégration pour une application Web de printemps et j'ai atteint une étape où j'ai besoin de simuler des appels de méthodes de service qui ont un type de retour avide. J'ai fait des recherches sur certains moyens de le faire, mais aucun ne semble être la bonne façon.

Ce que je veux faire est: p>

• Lorsque la méthode Enregistrer () est appelée sur Recipesservice, elle devrait enregistrer la recette li> ul>

  ci-dessous, je vais fournir le code et les deux façons principales que j'ai déjà essayées. Si quelqu'un peut aider ce serait génial! P>

  la méthode qui nécessite de se moquer de fort> p> xxx pré>

  le service qui a besoin Appelant (Méthode de sauvegarde) FORT> P>

  @RunWith(SpringRunner.class)
  @SpringBootTest(classes = Application.class)
  @WebAppConfiguration
  public class RecipeControllerTests {
  
  private MockMvc mockMvc;
  
  @Mock
  private RecipeService recipeService;
  
  @Mock
  private UserService userService;
  
  @Mock
  private IngredientService ingredientService;
  
  @Autowired
  WebApplicationContext wac;
  
  @InjectMocks
  private RecipeController recipeController;
  
  @Before
  public void setUp() throws Exception {
      MockitoAnnotations.initMocks(this);
      mockMvc = MockMvcBuilders.webAppContextSetup(wac).apply(springSecurity()).build();
  }
  
  /**
   * Tests for index pages / & /recipes
   */
  @Test
  @WithUserDetails(value = "daniel")
  public void indexPageLoads() throws Exception {
      List<Recipe> recipes = recipeListBuilder();
      List<Ingredient> ingredients = ingredientsListBuilder();
  
      when(recipeService.findAll()).thenReturn(recipes);
      when(ingredientService.findAll()).thenReturn(ingredients);
      when(userService.findByUsername("daniel")).thenReturn(userBuilder());
  
      mockMvc.perform(get("/recipes"))
              .andExpect(model().attributeExists("recipes", "ingredients", "favs"))
              .andExpect(status().isOk());
  }
  
  /**
   * Tests for page /recipes/add
   */
  @Test
  @WithMockUser
  public void addRecipePageLoads() throws Exception {
      mockMvc.perform(get("/recipes/add"))
              .andExpect(model().attributeExists("task", "buttonAction", "action", "photo", "recipe"))
              .andExpect(status().isOk());
  }
  
  @Test
  @WithUserDetails("daniel")
  public void createNewRecipeRedirects() throws Exception {
      User user = userBuilder();
      Recipe recipe = recipeBuilder(1L);
      recipe.setOwner(user);
      user.addFavorite(recipe);
      MultipartFile photo = new MockMultipartFile("image", "food.jpeg",
              "image/jpeg", "dummy content file".getBytes());
  
      when(userService.findByUsername("daniel")).thenReturn(user);
      verify(recipeService, times(1)).save(recipe, photo);
      verify(userService, times(1)).save(user);
  
  
      mockMvc.perform(post("/recipes/add"))
              .andExpect(redirectedUrl("/recipes"))
              .andExpect(flash().attributeExists("flash"));
  
  
  }
  
  
  private User userBuilder() {
      User user = new User();
      user.setFavorites(recipeListBuilder());
      user.setId(1L);
      user.setRoles(new String[]{"ROLE_USER", "ROLE_ADMIN"});
      user.setUsername("daniel");
      user.setPassword("password");
  
      return user;
  }
  
  private List<Recipe> recipeListBuilder() {
      List<Recipe> recipes =  new ArrayList<>();
      recipes.add(recipeBuilder(1L));
      recipes.add(recipeBuilder(2L));
  
      return recipes;
  }
  
  private List<Ingredient> ingredientsListBuilder() {
      List<Ingredient> ingredients = new ArrayList<>();
      ingredients.add(ingredientBuilder());
  
      return ingredients;
  }
  
  private Ingredient ingredientBuilder() {
      Ingredient ingredient = new Ingredient();
      ingredient.setCondition("good");
      ingredient.setName("test ing");
      ingredient.setQuantity(1);
      ingredient.setId(1L);
  
      return ingredient;
  }
  
  private Recipe recipeBuilder(Long id) {
      Recipe recipe = new Recipe();
      recipe.setName("Test recipe");
      recipe.setDescription("Test Description");
      recipe.setId(id);
      recipe.setCategory(Category.ALL_CATEGORIES);
      recipe.setCookTime(10);
      recipe.setPrepTime(10);
      recipe.addIngredient(ingredientBuilder());
  
      return recipe;
  }
  }