boom/tests/test_AdminController.cpp

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "AdminController.h"
#include "BusinessService.h"
#include "Product.h"
#include "Order.h"
#include "Refund.h"

using namespace std;
using namespace testing;

// Mock BusinessService
class MockBusinessService : public BusinessService {
public:
    MOCK_METHOD(Product, addProduct, (const Product&), (override));
    MOCK_METHOD(Product, updateProduct, (Long, const Product&), (override));
    MOCK_METHOD(bool, deleteProduct, (Long), (override));
    MOCK_METHOD(Product, updateProductStatus, (Long, const string&), (override));
    MOCK_METHOD(list<Order>, getAllOrders, (), (override));
    MOCK_METHOD(Order, updateOrderStatus, (Long, const string&), (override));
    MOCK_METHOD(list<Refund>, getAllRefunds, (), (override));
    MOCK_METHOD(Refund, approveRefund, (Long, Long), (override));
    MOCK_METHOD(Refund, rejectRefund, (Long, Long, const string&), (override));
};

// Test fixture for AdminController
class AdminControllerTest : public Test {
protected:
    MockBusinessService mockBusinessService;
    AdminController adminController{mockBusinessService};

    // Helper function to create a test product
    Product createTestProduct() {
        Product p;
        p.setId(1L);
        p.setName("Test Product");
        p.setPrice(99.99);
        return p;
    }

    // Helper function to create a test order
    Order createTestOrder() {
        Order o;
        o.setId(1L);
        o.setStatus("PAID");
        return o;
    }

    // Helper function to create a test refund
    Refund createTestRefund() {
        Refund r;
        r.setId(1L);
        r.setStatus("PENDING");
        return r;
    }
};

// Test: 正常输入测试 - addProduct
TEST_F(AdminControllerTest, testAddProductNormalInput) {
    Product inputProduct = createTestProduct();
    Product expectedProduct = createTestProduct();
    EXPECT_CALL(mockBusinessService, addProduct(inputProduct)).WillOnce(Return(expectedProduct));

    auto response = adminController.addProduct(inputProduct);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::CREATED);
    EXPECT_EQ(response.getBody().getId(), expectedProduct.getId());
    EXPECT_EQ(response.getBody().getName(), expectedProduct.getName());
}

// Test: 边界值测试 - addProduct with empty product
TEST_F(AdminControllerTest, testAddProductEmptyProduct) {
    Product emptyProduct;
    emptyProduct.setId(0L);
    emptyProduct.setName("");
    emptyProduct.setPrice(0.0);

    EXPECT_CALL(mockBusinessService, addProduct(emptyProduct)).WillOnce(Return(emptyProduct));

    auto response = adminController.addProduct(emptyProduct);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::CREATED);
    EXPECT_EQ(response.getBody().getId(), 0L);
    EXPECT_TRUE(response.getBody().getName().empty());
}

// Test: 异常输入测试 - updateProduct with invalid ID
TEST_F(AdminControllerTest, testUpdateProductInvalidId) {
    Product product = createTestProduct();
    EXPECT_CALL(mockBusinessService, updateProduct(-1L, product)).WillOnce(Return(product));

    auto response = adminController.updateProduct(-1L, product);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::OK);
    EXPECT_EQ(response.getBody().getId(), product.getId());
}

// Test: 特殊场景测试 - updateProductStatus with valid status
TEST_F(AdminControllerTest, testUpdateProductStatusValidStatus) {
    string status = "ON";
    map<string, string> request;
    request["status"] = status;

    Product updatedProduct = createTestProduct();
    EXPECT_CALL(mockBusinessService, updateProductStatus(1L, status)).WillOnce(Return(updatedProduct));

    auto response = adminController.updateProductStatus(1L, request);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::OK);
    EXPECT_EQ(response.getBody().getId(), updatedProduct.getId());
}

// Test: 边界值测试 - updateProductStatus with null status
TEST_F(AdminControllerTest, testUpdateProductStatusNullStatus) {
    map<string, string> request;
    request["status"] = "";

    Product updatedProduct = createTestProduct();
    EXPECT_CALL(mockBusinessService, updateProductStatus(1L, "")).WillOnce(Return(updatedProduct));

    auto response = adminController.updateProductStatus(1L, request);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::OK);
    EXPECT_EQ(response.getBody().getId(), updatedProduct.getId());
}

// Test: 正常输入测试 - updateOrderStatus
TEST_F(AdminControllerTest, testUpdateOrderStatusNormalInput) {
    string status = "SHIPPED";
    map<string, string> request;
    request["status"] = status;

    Order updatedOrder = createTestOrder();
    EXPECT_CALL(mockBusinessService, updateOrderStatus(1L, status)).WillOnce(Return(updatedOrder));

    auto response = adminController.updateOrderStatus(1L, request);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::OK);
    EXPECT_EQ(response.getBody().getId(), updatedOrder.getId());
    EXPECT_EQ(response.getBody().getStatus(), status);
}

// Test: 特殊场景测试 - approveRefund with valid ID
TEST_F(AdminControllerTest, testApproveRefundValidId) {
    Refund approvedRefund = createTestRefund();
    approvedRefund.setStatus("APPROVED");

    EXPECT_CALL(mockBusinessService, approveRefund(1L, 1L)).WillOnce(Return(approvedRefund));

    auto response = adminController.approveRefund(1L);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::OK);
    EXPECT_EQ(response.getBody().getId(), approvedRefund.getId());
    EXPECT_EQ(response.getBody().getStatus(), approvedRefund.getStatus());
}

// Test: 异常输入测试 - rejectRefund with null remark
TEST_F(AdminControllerTest, testRejectRefundNullRemark) {
    map<string, string> request;
    request.clear();

    Refund rejectedRefund = createTestRefund();
    rejectedRefund.setStatus("REJECTED");
    rejectedRefund.setRemark("退款申请被拒绝");

    EXPECT_CALL(mockBusinessService, rejectRefund(1L, 1L, "退款申请被拒绝")).WillOnce(Return(rejectedRefund));

    auto response = adminController.rejectRefund(1L, request);

    EXPECT_EQ(response.getStatusCode(), HttpStatus::OK);
    EXPECT_EQ(response.getBody().getId(), rejectedRefund.getId());
    EXPECT_EQ(response.getBody().getStatus(), rejectedRefund.getStatus());
    EXPECT_EQ(response.getBody().getRemark(), rejectedRefund.getRemark());
}