6

试图解决这个问题真的很难有谁能帮助我吗?

我显然在做一些根本错误的事情,我试图验证每个 Mock 对象,但它似乎不起作用。

 org.mockito.exceptions.misusing.UnfinishedVerificationException: 
 Missing method call for verify(mock) here:
 -> at     com.muuves.reservosity.service.TestProductServiceImpl.search_OneHourSlot_TwoBookingAvailable(TestProductServiceImpl.java:86)

 Example of correct verification:
verify(mock).doSomething()

Also, this error might show up because you verify either of: final/private/equals()  /hashCode() methods.
Those methods *cannot* be stubbed/verified.

at com.muuves.reservosity.service.TestProductServiceImpl.setUp(TestProductServiceImpl.java:41)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
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.RunBefores.evaluate(RunBefores.java:27)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:76)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
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.junit.runners.ParentRunner.run(ParentRunner.java:236)
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)

这是我的测试

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

public class TestProductServiceImpl {    
    ProductServiceImpl instance;
    @Mock
    EntityManager em;
    @Mock
    CriteriaBuilder builder;
    @Mock 
    CriteriaQuery<Product_Details> c;
    @Mock
    Root<Product_Details> productRoot;
    @Mock
    TypedQuery<Product_Details> typedQuery;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this); 
        instance = new  ProductServiceImpl();
        instance.setEm(em);
        instance.setCriteriaBuilder(builder);
        instance.setQuery(c);
        instance.setProductRoot(productRoot);
        instance.setTypedQuery(typedQuery);
    }

    @Test
    public void search_OneHourSlot_NoBookingAvailable() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("14:00-15:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(0, result.size());
    }
    @Test
    public void search_OneHourSlot_TwoBookingAvailable() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("14:00-17:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(1, result.size());
        Assert.assertEquals("2013-02-09 15:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
    }

    @Test
    public void search_OneHourSlot_EndTimeAfterClosing() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("14:00-20:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(1, result.size());
        Assert.assertEquals("2013-02-09 15:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
        verify(em);
    }

    @Test
    public void search__StartTimeBeforeOpening() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("08:00-13:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(3, result.size());
        Assert.assertEquals("2013-02-09 09:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 10:00", result.get(1).getTime());
        Assert.assertEquals("Google", result.get(1).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 11:00", result.get(2).getTime());
        Assert.assertEquals("Google", result.get(2).getProductDetails().getProduct_Name());
    }
    @Test
    public void search__StartTimeAndEndTimeBeforeOpening() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("06:00-09:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(0, result.size());
    }
    @Test
    public void search__StartTimeAndEndTimeAfterClosing() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("17:00-21:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(0, result.size());
    }
    @Test
    public void search__StartTimeAndEndTimeExactlyOpeningClosing() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("09:00-17:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(5, result.size());
        Assert.assertEquals("2013-02-09 09:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 10:00", result.get(1).getTime());
        Assert.assertEquals("Google", result.get(1).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 11:00", result.get(2).getTime());
        Assert.assertEquals("Google", result.get(2).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 13:00", result.get(3).getTime());
        Assert.assertEquals("Google", result.get(3).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 15:00", result.get(4).getTime());
        Assert.assertEquals("Google", result.get(4).getProductDetails().getProduct_Name());
    }
    private List<Product_Details> booking(int slot){
        List<Product_Details> products = new ArrayList<Product_Details>();
        Product_Details product = new Product_Details();
        product.setProduct_Name("Google");
        product.setSaturday_Open("09:00-17:00");
        product.setDates_Closed("2013-12-25");
        product.setTime_Per_Slot(slot);
        List<Booking_Details> bookings = new ArrayList<Booking_Details>();
        Booking_Details booking1 = new Booking_Details();
        booking1.setBooked_Date("2013-02-09 12:00");
        bookings.add(booking1);
        Booking_Details booking2 = new Booking_Details();
        booking2.setBooked_Date("2013-02-09 14:00");
        bookings.add(booking2);
        Booking_Details booking3 = new Booking_Details();
        booking3.setBooked_Date("2013-02-09 16:00");
        bookings.add(booking3);
        product.setBookings(bookings);
        products.add(product);
        return products;
    }
}

如果有人可以帮助我,那就太好了。

4

3 回答 3

5

您试图以错误的方式使用 Mockito 框架的验证方法。它用于验证某些行为是否发生过一次。在您的测试中,您应该指定发生了什么行为(行为意味着方法调用)。

这是一个检查发送邮件的方法的测试示例:

@RunWith(MockitoJUnitRunner.class)
public class MailSenderTest {

    @Mock
    private JavaMailSender javaMailSender;

    @InjectMocks
    private MailSenderImpl mailSender;

    @Test
    public void testSendMail() {

        String from = "somemail@gmail.com";
        String to = "Danothermail@gmail.com";
        String title = "Test";
        String text = "Hello world!";

        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(title);
        message.setText(text);

        mailSender.sendMail(to, title, text);

        Mockito.verify(javaMailSender).send(message);
    }

}

正如您在 verify(..) 之后从该示例中看到的那样,我指定了要检查的方法调用。换句话说,通过示例的最后一行,我检查了在执行 JavaMailSender 的服务方法 send(..) 的 sendMail(...) 方法期间是否使用正确的参数调用了该方法。

查看mockito官方页面。有很多简单有用的例子,描述得很好。这是它的链接。

于 2013-02-09T19:23:22.503 回答
0

错误消息表明,您verify(em)...;在受影响的测试方法中缺少调用search_OneHourSlot_TwoBookingAvailable()

我强烈建议重新格式化您的测试代码,至少将每个测试方法中的断言与测试代码分开。

于 2013-02-09T17:01:45.100 回答
0

将此添加到每个测试中并且可以正常工作,感谢 harpun 你真的在这里帮助了我

    verify(em).createQuery(c);
    verify(builder).createQuery(Product_Details.class);
    verify(c).from(Product_Details.class);
    verify(em).createQuery(c);
    verify(typedQuery).getResultList();
于 2013-02-10T12:15:28.210 回答