如何使用Mockito测试业务层？

Question

我在春季启动项目中使用mockito有问题。我应该做些什么来测试业务层？(我只有建筑工人测试)。

公共类ProductBuilder {

private Product product;
private Collection<Product> products;

public static ProductBuilder mockProductBuilder() {
    ProductBuilder builder = new ProductBuilder();
    builder.product = new Product("Beer", "Alcholic", "20,99", "Montez");

    return builder;
}

public static ProductBuilder mockCollectionProductBuilder() {
    ProductBuilder builder = new ProductBuilder();
    builder.products = new ArrayList<Product>();

    for (int i = 0; i < 10; i++) {
        Product product = new Product("Beer " + i, "Alcholic", "20,99" + i, "Montez");

        builder.products.add(product);
    }

    return builder;
}

// Methods
public Product  getProduct() {
    return this.product;
}

public Collection<Product> getProducts() {
    return this.products;
}

Answer 1

您需要对类控制器、存储库和服务进行测试。你的建设者很好，你的控制器应该喜欢这样的东西

@SpringBootTest
public class ProductControllerTest {

    @InjectMocks
    private ProductController productController;

    @Mock
    private ProductService productService;
    @Mock
    private BindingResult bindingResult;

    private Model model;

    private Product productOptional;
    private List<Product> products;
    private Product product;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        this.productOptional = ProductBuilder.mockProductBuilder().getProduct();
        this.products = (List<Product>) ProductBuilder.mockCollectionProductBuilder().getProducts();
        this.product = ProductBuilder.mockProductBuilder().getProduct();

        this.model = new ConcurrentModel();
    }

    @Test
    public void index() {
        Mockito.when(this.productService.searchAll()).thenReturn(this.products);

        Assert.assertEquals(this.productController.index(this.model), "product/index");
        Assert.assertEquals(this.model.containsAttribute("products"), true);
    }

    @Test
    public void create() {
        Assert.assertEquals(this.productController.add(product, this.model), "product/addProduct");
    }


    @Test
    public void update() {
        Mockito.when(this.productService.searchById((long) 1)).thenReturn(this.productOptional);

        Assert.assertEquals(this.productController.edit((long) 0, this.model), "product/editProduct");
        Assert.assertEquals(this.model.containsAttribute("product"), false); 
    }


    @Test
    public void save() {
        Mockito.when(this.productService.inserir(this.product)).thenReturn(this.product);
        Mockito.when(this.bindingResult.hasErrors()).thenReturn(true);
        Assert.assertEquals(this.productController.save(this.product, this.bindingResult, this.model), "product/addProduct");
    }

    @Test
    public void saveError() {
        Mockito.when(this.productService.inserir(this.product)).thenReturn(this.product);
        Mockito.when(this.bindingResult.hasErrors()).thenReturn(true);
        Assert.assertEquals(this.productController.save(this.product, this.bindingResult, this.model), "product/addProduct");
    }

    @Test
    public void delete() {
        Assert.assertEquals(this.productController.delete((long) 1, this.model), "product/index");
        Mockito.verify(this.productService, Mockito.times(1)).deletar((long) 1);
    }
}

Answer 2

用于存储库

@RunWith(SpringRunner.class)

@SpringBootTest公共类ProductRepositoryTest {

@Autowired
private ProductRepository productRepository;

private Product product;

@Before
public void setUp() {
    this.product = ProductBuilder.mockProductBuilder().getProduct();  
}

@After
public void after() {
    this.productRepository.deleteAll();
}

@Test
public void findAll() {
    Assert.assertThat(this.productRepository.findAll(), instanceOf(List.class));
}

@Test
public void findById() {
    Assert.assertThat(this.productRepository.findById((long) 2), instanceOf(Optional.class));
}

@Test
public void saveCreate() {

    this.product.setId((long) 1);
    this.product = this.productRepository.save(this.product);
    //Assert.assertNotEquals(this.product.getId(), 1);
}

@Test
public void saveUpdate() {

    this.product.setId((long) 0);
    this.product = this.productRepository.save(this.product);
    this.product.setNome("Jonas");
    Product productAtualizado = this.productRepository.save(this.product);
    Assert.assertEquals(productAtualizado.getNome(), this.product.getNome());
} 

@Test
public void deleteById() {
    this.product = this.productRepository.save(this.product);
    this.productRepository.deleteById(this.product.getId());

    Assert.assertEquals(this.productRepository.findAll().size(), 0);
}

Answer 3

为服务部门

@SpringBootTest公共类ProductServiceTest {

@InjectMocks
private ProductService productService;

@Mock
private ProductRepository productRepository;

private Product productTest;
private List<Product> products;

@Before
public void setUp() {
    MockitoAnnotations.initMocks(this);
    this.productTest = ProductBuilder.mockProductBuilder().getProduct();
    this.products = (List<Product>) ProductBuilder.mockCollectionProductBuilder().getProducts();
}

@Test
public void buscarTodosTest() {
    Mockito.when(this.productRepository.findAll()).thenReturn(this.products);

    List<Product> productsBd = this.productService.buscarTodos();

    assertEquals(productsBd, this.products);
}

@Test
public void buscarPeloId() {
    Optional<Product> productOptional = Optional.of(this.productTest);
    Mockito.when(this.productRepository.findById(this.productTest.getId())).thenReturn(productOptional);

    Product product = this.productService.buscarPeloId(this.productTest.getId());

    assertEquals(product, productOptional.get());
}

@Test
public void inserirTest() {
    Mockito.when(this.productRepository.save(this.productTest)).thenReturn(this.productTest);

    Product productSalvo = this.productService.inserir(this.productTest);

    assertEquals(productSalvo, this.productTest);
}

@Test
public void atualizarTest() {
    Optional<Product> productOptional = Optional.of(this.productTest);
    this.productTest.setId((long) 1);

    Mockito.when(this.productRepository.save(this.productTest)).thenReturn(this.productTest);
    Mockito.when(this.productRepository.findById(this.productTest.getId())).thenReturn(productOptional);

    Product productAtualizado = this.productService.atualizar(this.productTest);

    assertEquals(productAtualizado, this.productTest);
}

@Test
public void deletarTest() {
    Optional<Product> productOptional = Optional.of(this.productTest);

    Mockito.when(this.productRepository.findById(this.productTest.getId())).thenReturn(productOptional);

    this.productService.deletar(this.productTest.getId());

    Mockito.verify(this.productRepository, Mockito.times(1)).findById(this.productTest.getId());
}