foodie-server/ruoyi-admin/src/test/java/com/ruoyi/app/unifiedorder/UnifiedOrderTabTest.java

package com.ruoyi.app.unifiedorder;

import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.ruoyi.system.domain.PosOrder;
import com.ruoyi.system.domain.flash.FlashDeliveryOrder;
import com.ruoyi.system.domain.flash.FlashDeliveryStatus;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

import java.util.Collection;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

/** 统一订单列表 tab 归类：两域内存判定全覆盖，规则照抄用户端订单列表现行语义。 */
class UnifiedOrderTabTest {

    @BeforeAll
    static void initializeTableMetadata() {
        TableInfoHelper.initTableInfo(
                new MapperBuilderAssistant(new MybatisConfiguration(), ""), PosOrder.class);
        TableInfoHelper.initTableInfo(
                new MapperBuilderAssistant(new MybatisConfiguration(), ""), FlashDeliveryOrder.class);
    }

    // ---------- fromCode / queriesFlash ----------

    @Test
    void fromCodeDefaultsToAllAndRejectsUnknownValues() {
        assertSame(UnifiedOrderTab.ALL, UnifiedOrderTab.fromCode(null));
        assertSame(UnifiedOrderTab.ALL, UnifiedOrderTab.fromCode(""));
        assertSame(UnifiedOrderTab.ALL, UnifiedOrderTab.fromCode("  "));
        assertSame(UnifiedOrderTab.ALL, UnifiedOrderTab.fromCode("all"));
        assertSame(UnifiedOrderTab.UNPAID, UnifiedOrderTab.fromCode("unpaid"));
        assertSame(UnifiedOrderTab.ACTIVE, UnifiedOrderTab.fromCode("active"));
        assertSame(UnifiedOrderTab.COMPLETED, UnifiedOrderTab.fromCode("completed"));
        assertSame(UnifiedOrderTab.CANCELLED, UnifiedOrderTab.fromCode("cancelled"));
        assertSame(UnifiedOrderTab.REFUND, UnifiedOrderTab.fromCode("refund"));
        assertNull(UnifiedOrderTab.fromCode("bogus"));
        assertNull(UnifiedOrderTab.fromCode("ALL"));
    }

    @Test
    void unpaidAndRefundTabsNeverQueryFlash() {
        assertFalse(UnifiedOrderTab.UNPAID.queriesFlash());
        assertFalse(UnifiedOrderTab.REFUND.queriesFlash());
        assertTrue(UnifiedOrderTab.ALL.queriesFlash());
        assertTrue(UnifiedOrderTab.ACTIVE.queriesFlash());
        assertTrue(UnifiedOrderTab.COMPLETED.queriesFlash());
        assertTrue(UnifiedOrderTab.CANCELLED.queriesFlash());
    }

    // ---------- 外卖内存判定 ----------

    @Test
    void unpaidMatchesOnlyUnpaidOnlineOrders() {
        // 在线支付未付
        assertTrue(UnifiedOrderTab.UNPAID.matches(pos(0L, 0L, 0L, "2", 0L)));
        assertTrue(UnifiedOrderTab.UNPAID.matches(pos(3L, 2L, 0L, "3", 0L)));
        // 已付不进待付款
        assertFalse(UnifiedOrderTab.UNPAID.matches(pos(0L, 0L, 1L, "2", 0L)));
        // 货到付款/现金不进待付款（沿用现有语义：仅在线支付未付）
        assertFalse(UnifiedOrderTab.UNPAID.matches(pos(0L, 0L, 0L, "1", 0L)));
        assertFalse(UnifiedOrderTab.UNPAID.matches(pos(0L, 0L, 0L, "4", 0L)));
        // 已取消不进待付款
        assertFalse(UnifiedOrderTab.UNPAID.matches(pos(4L, 0L, 0L, "2", 0L)));
        // 售后中不进待付款
        assertFalse(UnifiedOrderTab.UNPAID.matches(pos(0L, 0L, 0L, "2", 1L)));
    }

    @Test
    void activeMatchesFulfillingOrdersWithoutAfterSale() {
        // 在线已付履约中
        assertTrue(UnifiedOrderTab.ACTIVE.matches(pos(0L, 0L, 1L, "2", 0L)));
        assertTrue(UnifiedOrderTab.ACTIVE.matches(pos(2L, 0L, 1L, "3", 0L)));
        // 货到付款（payType=1）/现金（payType=4）仅自取/堂食可履约
        assertTrue(UnifiedOrderTab.ACTIVE.matches(pos(1L, 1L, 0L, "1", 0L)));
        assertTrue(UnifiedOrderTab.ACTIVE.matches(pos(2L, 2L, 0L, "1", 0L)));
        assertFalse(UnifiedOrderTab.ACTIVE.matches(pos(0L, 0L, 0L, "1", 0L)));
        assertTrue(UnifiedOrderTab.ACTIVE.matches(pos(1L, 1L, 0L, "4", 0L)));
        assertTrue(UnifiedOrderTab.ACTIVE.matches(pos(2L, 2L, 0L, "4", 0L)));
        assertFalse(UnifiedOrderTab.ACTIVE.matches(pos(0L, 0L, 0L, "4", 0L)));
        // 在线未付不履约
        assertFalse(UnifiedOrderTab.ACTIVE.matches(pos(0L, 0L, 0L, "2", 0L)));
        // 终态不进进行中
        assertFalse(UnifiedOrderTab.ACTIVE.matches(pos(3L, 0L, 1L, "2", 0L)));
        assertFalse(UnifiedOrderTab.ACTIVE.matches(pos(4L, 0L, 1L, "2", 0L)));
        // 售后单从进行中剔除
        assertFalse(UnifiedOrderTab.ACTIVE.matches(pos(1L, 0L, 1L, "2", 2L)));
    }

    @Test
    void completedMatchesStateThreeWithoutAfterSale() {
        assertTrue(UnifiedOrderTab.COMPLETED.matches(pos(3L, 0L, 1L, "2", 0L)));
        assertFalse(UnifiedOrderTab.COMPLETED.matches(pos(2L, 0L, 1L, "2", 0L)));
        assertFalse(UnifiedOrderTab.COMPLETED.matches(pos(3L, 0L, 1L, "2", 1L)));
    }

    @Test
    void cancelledMatchesStateFourWithoutAfterSale() {
        assertTrue(UnifiedOrderTab.CANCELLED.matches(pos(4L, 0L, 0L, "2", 0L)));
        assertFalse(UnifiedOrderTab.CANCELLED.matches(pos(3L, 0L, 1L, "2", 0L)));
        assertFalse(UnifiedOrderTab.CANCELLED.matches(pos(4L, 0L, 0L, "2", 1L)));
    }

    @Test
    void refundMatchesAnyAfterSaleMark() {
        assertTrue(UnifiedOrderTab.REFUND.matches(pos(1L, 0L, 1L, "2", 1L)));
        // payStatus=2 已退款必然带售后标记，归退款 tab
        assertTrue(UnifiedOrderTab.REFUND.matches(pos(4L, 0L, 2L, "2", 3L)));
        assertFalse(UnifiedOrderTab.REFUND.matches(pos(4L, 0L, 1L, "2", 0L)));
    }

    @Test
    void allTabNeverFiltersTakeawayOrders() {
        for (long state = 0; state <= 4; state++) {
            for (long afterSale = 0; afterSale <= 3; afterSale++) {
                assertTrue(UnifiedOrderTab.ALL.matches(pos(state, 0L, 0L, "2", afterSale)),
                        "state=" + state + ", afterSale=" + afterSale);
            }
        }
    }

    @Test
    void nullFieldsNeverMatchConstrainedTabs() {
        PosOrder sparse = new PosOrder();
        assertFalse(UnifiedOrderTab.UNPAID.matches(sparse));
        assertFalse(UnifiedOrderTab.ACTIVE.matches(sparse));
        assertFalse(UnifiedOrderTab.COMPLETED.matches(sparse));
        assertFalse(UnifiedOrderTab.CANCELLED.matches(sparse));
        assertFalse(UnifiedOrderTab.REFUND.matches(sparse));
        assertTrue(UnifiedOrderTab.ALL.matches(sparse));
    }

    // ---------- 闪送内存判定 ----------

    @Test
    void flashNonFinalStatusesMapToActive() {
        for (String status : new String[]{FlashDeliveryStatus.WAITING_ACCEPTANCE,
                FlashDeliveryStatus.ACCEPTED, FlashDeliveryStatus.PICKED_UP,
                FlashDeliveryStatus.DELIVERED}) {
            FlashDeliveryOrder order = flash(status);
            assertTrue(UnifiedOrderTab.ACTIVE.matches(order), status);
            assertFalse(UnifiedOrderTab.COMPLETED.matches(order), status);
            assertFalse(UnifiedOrderTab.CANCELLED.matches(order), status);
            assertFalse(UnifiedOrderTab.UNPAID.matches(order), status);
            assertFalse(UnifiedOrderTab.REFUND.matches(order), status);
            assertTrue(UnifiedOrderTab.ALL.matches(order), status);
        }
    }

    @Test
    void flashCompletedMapsOnlyToCompleted() {
        FlashDeliveryOrder order = flash(FlashDeliveryStatus.COMPLETED);
        assertTrue(UnifiedOrderTab.COMPLETED.matches(order));
        assertFalse(UnifiedOrderTab.ACTIVE.matches(order));
        assertFalse(UnifiedOrderTab.CANCELLED.matches(order));
    }

    @Test
    void flashCancelledMapsOnlyToCancelled() {
        FlashDeliveryOrder order = flash(FlashDeliveryStatus.CANCELLED);
        assertTrue(UnifiedOrderTab.CANCELLED.matches(order));
        assertFalse(UnifiedOrderTab.ACTIVE.matches(order));
        assertFalse(UnifiedOrderTab.COMPLETED.matches(order));
    }

    @Test
    void flashStatusNullFailsAllConstrainedTabs() {
        FlashDeliveryOrder order = flash(null);
        assertFalse(UnifiedOrderTab.ACTIVE.matches(order));
        assertFalse(UnifiedOrderTab.COMPLETED.matches(order));
        assertFalse(UnifiedOrderTab.CANCELLED.matches(order));
        assertTrue(UnifiedOrderTab.ALL.matches(order));
    }

    // ---------- wrapper SQL 片段断言（防 SQL 构造与 matches 内存判定漂移） ----------

    @Test
    void unpaidWrapperCarriesOnlineUnpaidConditions() {
        LambdaQueryWrapper<PosOrder> wrapper = UnifiedOrderTab.UNPAID.posOrderWrapper();
        String sql = wrapper.getSqlSegment();
        assertTrue(sql.contains("pay_status ="), sql);
        assertTrue(sql.contains("pay_type IN"), sql);
        assertTrue(sql.contains("state <>"), sql);
        assertTrue(sql.contains("after_sale_status ="), sql);
        Collection<Object> params = wrapper.getParamNameValuePairs().values();
        assertTrue(params.containsAll(List.of("2", "3")), params.toString());
    }

    @Test
    void activeWrapperCarriesStateAndPaymentConditions() {
        LambdaQueryWrapper<PosOrder> wrapper = UnifiedOrderTab.ACTIVE.posOrderWrapper();
        String sql = wrapper.getSqlSegment();
        assertTrue(sql.contains("state IN"), sql);
        assertTrue(sql.contains("after_sale_status ="), sql);
        assertTrue(sql.contains("(pay_status ="), sql);
        assertTrue(sql.contains("OR (pay_type IN"), sql);
        assertTrue(sql.contains("type IN"), sql);
        assertTrue(wrapper.getParamNameValuePairs().values()
                .containsAll(java.util.List.of("1", "4")), wrapper.getParamNameValuePairs().toString());
    }

    @Test
    void terminalTabWrappersCarryStateAndAfterSaleConditions() {
        LambdaQueryWrapper<PosOrder> completedWrapper = UnifiedOrderTab.COMPLETED.posOrderWrapper();
        String completed = completedWrapper.getSqlSegment();
        assertTrue(completed.contains("state ="), completed);
        assertTrue(completed.contains("after_sale_status ="), completed);
        assertTrue(completedWrapper.getParamNameValuePairs().containsValue(3L),
                completedWrapper.getParamNameValuePairs().toString());
        LambdaQueryWrapper<PosOrder> cancelledWrapper = UnifiedOrderTab.CANCELLED.posOrderWrapper();
        String cancelled = cancelledWrapper.getSqlSegment();
        assertTrue(cancelled.contains("state ="), cancelled);
        assertTrue(cancelledWrapper.getParamNameValuePairs().containsValue(4L),
                cancelledWrapper.getParamNameValuePairs().toString());
    }

    @Test
    void refundWrapperFiltersAfterSaleMark() {
        String sql = UnifiedOrderTab.REFUND.posOrderWrapper().getSqlSegment();
        assertTrue(sql.contains("after_sale_status >"), sql);
    }

    @Test
    void allTabWrapperHasNoConditions() {
        String takeawaySql = UnifiedOrderTab.ALL.posOrderWrapper().getSqlSegment();
        assertTrue(takeawaySql == null || takeawaySql.isBlank(), String.valueOf(takeawaySql));
        String flashSql = UnifiedOrderTab.ALL.flashWrapper().getSqlSegment();
        assertTrue(flashSql == null || flashSql.isBlank(), String.valueOf(flashSql));
    }

    @Test
    void flashActiveWrapperContainsFourNonFinalStatuses() {
        LambdaQueryWrapper<FlashDeliveryOrder> wrapper = UnifiedOrderTab.ACTIVE.flashWrapper();
        assertTrue(wrapper.getSqlSegment().contains("status IN"), wrapper.getSqlSegment());
        Collection<Object> params = wrapper.getParamNameValuePairs().values();
        assertTrue(params.containsAll(List.of(FlashDeliveryStatus.WAITING_ACCEPTANCE,
                FlashDeliveryStatus.ACCEPTED, FlashDeliveryStatus.PICKED_UP,
                FlashDeliveryStatus.DELIVERED)), params.toString());
    }

    @Test
    void flashTerminalTabWrappersMatchExactStatus() {
        LambdaQueryWrapper<FlashDeliveryOrder> completed = UnifiedOrderTab.COMPLETED.flashWrapper();
        assertTrue(completed.getSqlSegment().contains("status ="), completed.getSqlSegment());
        assertTrue(completed.getParamNameValuePairs().containsValue(FlashDeliveryStatus.COMPLETED));
        LambdaQueryWrapper<FlashDeliveryOrder> cancelled = UnifiedOrderTab.CANCELLED.flashWrapper();
        assertTrue(cancelled.getSqlSegment().contains("status ="), cancelled.getSqlSegment());
        assertTrue(cancelled.getParamNameValuePairs().containsValue(FlashDeliveryStatus.CANCELLED));
    }

    @Test
    void flashWrapperForAlwaysEmptyTabsThrows() {
        assertThrows(IllegalStateException.class, () -> UnifiedOrderTab.UNPAID.flashWrapper());
        assertThrows(IllegalStateException.class, () -> UnifiedOrderTab.REFUND.flashWrapper());
    }

    // ---------- helpers ----------

    private static PosOrder pos(Long state, Long type, Long payStatus, String payType, Long afterSaleStatus) {
        PosOrder order = new PosOrder();
        order.setState(state);
        order.setType(type);
        order.setPayStatus(payStatus);
        order.setPayType(payType);
        order.setAfterSaleStatus(afterSaleStatus);
        return order;
    }

    private static FlashDeliveryOrder flash(String status) {
        FlashDeliveryOrder order = new FlashDeliveryOrder();
        order.setStatus(status);
        return order;
    }
}