我为我的UserService类编写了一个模拟测试，但不明白为什么create方法的测试显示为橙子。我想弄清楚这是由于拼写错误的方法还是拼写错误的测试。这是我的命令类。

/**
 * A class that represents an order and contains the selected products and the customer.
 */

@Entity
@Table(name = "orders", schema = "public")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    //@JoinColumn
    private Product product;

    @ManyToMany
    private List<Product> products;

    @ManyToOne(fetch = FetchType.LAZY)
    //Multiple orders can belong to one customer. This means that a customer can place several orders.
    private User user;

    public Order() {
        //Default constructor
    }

    public Order(User user, Product product) {
        this.user = user;
        this.product = product;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Product getProduct() {
        return product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    public List<Product> getProducts() {
        return products;
    }
    public void setProducts(List<Product> products) {
        this.products = products;
    }
    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

我的OrderService类：

/**
 * A class that implements the order process and includes functions to create orders, display the order history of a customer and confirm the order.
 */
@Service
public class OrderService {
    @Autowired
    OrderRepository or;

    public void save(Order order) {
        or.save(order);
    }
    public List<Order> listAll(){
        return (List<Order>) or.findAll();
    }

    public Order create(User user, Product product) {
        Order newOrder = new Order();
        newOrder.setUser(user);
        newOrder.setProduct(product);
        return or.save(newOrder);
    }

    public void delete(Long id) {
        Optional<Order> existingOrder= or.findById(id);
        if(existingOrder.isPresent()){
            or.deleteById(id);
        } else {
            throw new IllegalArgumentException("Order with ID " + id + " not found.");
        }
    }
}

Meine Klasse订单存储库：

@Repository
    public interface OrderRepository extends CrudRepository<Order, Long> {
        long countById(Long id); }

下面是显示为橙子的模拟测试：

public class OrderServiceTest {

    @InjectMocks
    private OrderService orderService;
    @InjectMocks
    private ProductService productService;

    @Mock
    private OrderRepository orderRepository;
    @Mock
    private ProductRepository productRepository;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testCreateOrder() {
        MockitoAnnotations.openMocks(this);

        Product product = new Product();
        product.setProductName("productName_0");
        product.setProductSalePrice(1290.78);

        User mockUser = Mockito.mock(User.class); // Create a mock User object

        Order mockOrder = new Order();

        when(orderRepository.save(any(Order.class))).thenReturn(mockOrder);

        Order createdOrder = orderService.create(mockUser, product);

        assertNotNull(createdOrder);
        assertEquals(mockUser, createdOrder.getUser());
        assertEquals(product, createdOrder.getProduct());

        verify(orderRepository, times(1)).save(any(Order.class));
    }

enter image description here我已经尝试在测试中进行更改。因为在数据库中，它被正确地标记为“用户”，更具体地说是“用户ID”，所以这对我来说更令人困惑。