改写战斗中替换group的逻辑

mower/tests/base_scheduler_tests.py

@@ -0,0 +1,157 @@
+import unittest
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+
+from mower.solvers.base_schedule import BaseSchedulerSolver
+from mower.utils.logic_expression import LogicExpression
+from mower.utils.plan import Plan, PlanConfig, Room
+
+with patch.dict("sys.modules", {"RecruitSolver": MagicMock()}):
+    pass
+
+
+class TestBaseScheduler(unittest.TestCase):
+    @patch.object(BaseSchedulerSolver, "__init__", lambda x: None)
+    def test_backup_plan_solver_Caper(self):
+        plan_config = {
+            "meeting": [
+                Room("伊内丝", "", ["见行者", "陈"]),
+                Room("跃跃", "", ["见行者", "陈"]),
+            ]
+        }
+        plan_config1 = {
+            "meeting": [
+                Room("伊内丝", "", ["陈", "红"]),
+                Room("见行者", "", ["陈", "红"]),
+            ]
+        }
+        agent_base_config = PlanConfig("稀音", "稀音", "伺夜")
+        plan = {
+            # 阶段 1
+            "default_plan": Plan(plan_config, agent_base_config),
+            "backup_plans": [
+                Plan(
+                    plan_config1,
+                    agent_base_config,
+                    trigger=LogicExpression(
+                        "op_data.party_time is None", "and", " True "
+                    ),
+                    task={"meeting": ["Current", "见行者"]},
+                )
+            ],
+        }
+
+        solver = BaseSchedulerSolver()
+        solver.global_plan = plan
+        solver.initialize_operators()
+        solver.tasks = []
+        with patch.object(BaseSchedulerSolver, "agent_get_mood") as mock_agent_get_mood:
+            mock_agent_get_mood.return_value = None
+            solver.backup_plan_solver()
+            self.assertEqual(len(solver.tasks), 1)
+            print(solver.op_data.plan_name)
+            solver.party_time = datetime.now()
+            solver.backup_plan_solver()
+            self.assertEqual(solver.op_data.plan_name, "default_plan")
+
+    @patch.object(BaseSchedulerSolver, "__init__", lambda x: None)
+    def test_backup_plan_solver_GreyytheLightningbearer(self):
+        plan_config = {
+            "room_2_3": [Room("雷蛇", "澄闪", ["炎狱炎熔", "格雷伊"])],
+            "room_1_3": [Room("承曦格雷伊", "自动化", ["炎狱炎熔"])],
+            "room_2_1": [
+                Room("温蒂", "自动化", ["泡泡"]),
+                Room("森蚺", "自动化", ["火神"]),
+                Room("清流", "自动化", ["贝娜"]),
+            ],
+            "room_2_2": [Room("澄闪", "澄闪", ["炎狱炎熔", "格雷伊"])],
+            "central": [
+                Room("阿米娅", "", ["诗怀雅"]),
+                Room("琴柳", "乌有", ["清道夫"]),
+                Room("重岳", "乌有", ["杜宾"]),
+                Room("夕", "乌有", ["玛恩纳"]),
+                Room("令", "乌有", ["凯尔希"]),
+            ],
+            "contact": [Room("桑葚", "乌有", ["絮雨"])],
+        }
+        backup_plan1_config = {
+            "central": [
+                Room("阿米娅", "", ["诗怀雅"]),
+                Room("清道夫", "", ["诗怀雅"]),
+                Room("杜宾", "", ["泡泡"]),
+                Room("玛恩纳", "", ["火神"]),
+                Room("森蚺", "", ["诗怀雅"]),
+            ],
+            "room_2_1": [
+                Room("温蒂", "", ["泡泡"]),
+                Room("掠风", "", ["贝娜"]),
+                Room("清流", "", ["火神"]),
+            ],
+            "room_1_3": [Room("Lancet-2", "", ["承曦格雷伊"])],
+            "room_2_2": [Room("澄闪", "", ["承曦格雷伊", "格雷伊"])],
+            "room_2_3": [Room("雷蛇", "", ["承曦格雷伊", "格雷伊"])],
+            "contact": [Room("絮雨", "", ["桑葚"])],
+        }
+        agent_base_config0 = PlanConfig(
+            "稀音,黑键,焰尾,伊内丝",
+            "稀音,柏喙,伊内丝",
+            "伺夜,帕拉斯,雷蛇,澄闪,红云,乌有,年,远牙,阿米娅,桑葚,截云,掠风",
+            ling_xi=2,
+            resting_threshold=0.1,
+            run_order_buffer_time=20,
+        )
+        agent_base_config = PlanConfig(
+            "稀音,黑键,焰尾,伊内丝",
+            "稀音,柏喙,伊内丝",
+            "伺夜,帕拉斯,雷蛇,澄闪,红云,乌有,年,远牙,阿米娅,桑葚,截云",
+            ling_xi=2,
+            free_blacklist="艾丽妮,但书,龙舌兰",
+            run_order_buffer_time=20,
+        )
+        plan = {
+            # 阶段 1
+            "default_plan": Plan(plan_config, agent_base_config),
+            "backup_plans": [
+                Plan(
+                    backup_plan1_config,
+                    agent_base_config0,
+                    trigger=LogicExpression(
+                        "op_data.operators['令'].current_room.startswith('dorm')",
+                        "and",
+                        LogicExpression(
+                            "op_data.operators['温蒂'].current_mood() - op_data.operators['承曦格雷伊'].current_mood()",
+                            ">",
+                            "4",
+                        ),
+                    ),
+                    task={
+                        "dormitory_2": [
+                            "Current",
+                            "Current",
+                            "Current",
+                            "Current",
+                            "承曦格雷伊",
+                        ]
+                    },
+                )
+            ],
+        }
+
+        solver = BaseSchedulerSolver()
+        solver.global_plan = plan
+        solver.initialize_operators()
+        solver.tasks = []
+        with patch.object(BaseSchedulerSolver, "agent_get_mood") as mock_agent_get_mood:
+            mock_agent_get_mood.return_value = None
+            solver.op_data.operators["令"].current_room = "dorm"
+            solver.op_data.operators["温蒂"].mood = 12
+            solver.op_data.operators["承曦格雷伊"].mood = 7
+            solver.backup_plan_solver()
+            self.assertEqual(len(solver.tasks), 1)
+            solver.op_data.operators["承曦格雷伊"].mood = 12
+            solver.backup_plan_solver()
+            self.assertEqual(solver.op_data.plan_name, "default_plan")
+
+
+if __name__ == "__main__":
+    unittest.main()

mower/tests/cuoyu.py

@@ -0,0 +1,90 @@
+class Calculator:
+    def __init__(self):
+        self.input_日_钱_基建内_永远上班 = 50000
+        self.input_日_钱_基建内_暂时上班 = 30000
+        self.input_日_书_基建内 = 16500
+        self.input_预设土量 = 16000
+        self.input_搓玉人_效率和 = 2.1505
+        self.input_卖玉人_效率和 = 3
+        self.input_目标练度钱 = 761409
+        self.input_目标练度书 = 588286
+        self.目标练度钱书比 = self.input_目标练度钱 / self.input_目标练度书
+        self.练度列表 = []
+        self.练度列表_离谱 = []
+        self.日_钱_基建外 = 43482.63
+        self.日_书_基建外 = 36284.48
+
+    def 搓玉天数(self, 土量):
+        return int(土量 / 2 / 24 / self.input_搓玉人_效率和) + 1
+
+    def 搓玉用钱(self, 土量):
+        return 土量 * 800
+
+    def 卖玉天数(self, 土量):
+        return int(土量 / 2 / 2 / 24 * 2 / self.input_卖玉人_效率和) + 1
+
+    def calculate(self):
+        from itertools import product as 多循环
+
+        for 土量, 日_钱_基建内_永远上班, 日_书_基建内 in 多循环(
+            range(self.input_预设土量, 25000, 80),
+            range(self.input_日_钱_基建内_永远上班, 60000, 1000),
+            range(self.input_日_书_基建内, 20000, 1000),
+        ):
+            # 钱
+            搓玉所需钱数 = self.搓玉用钱(土量)
+            卖玉天数 = self.卖玉天数(土量)
+            基建内_年产钱 = (
+                日_钱_基建内_永远上班 * 365
+                + self.input_日_钱_基建内_暂时上班 * (365 - 卖玉天数)
+            )
+            总_年产钱 = 基建内_年产钱 + self.日_钱_基建外 * 365 - 搓玉所需钱数
+            # 书
+            搓玉天数 = self.搓玉天数(土量)
+            总_年产书 = 日_书_基建内 * (365 - 搓玉天数) + self.日_书_基建外 * 365
+            总_日产钱 = 总_年产钱 / 365
+            总_日产书 = 总_年产书 / 365
+            # 最终计算
+            日_钱书总数 = (
+                日_钱_基建内_永远上班 + self.input_日_钱_基建内_暂时上班 + 日_书_基建内
+            )
+            总_钱书比 = round(总_日产钱 / 总_日产书, 2)
+            总_能练干员 = int(
+                min(总_年产钱 / self.input_目标练度钱, 总_年产书, self.input_目标练度书)
+            )
+            日_钱_基建内 = int(日_钱_基建内_永远上班 + self.input_日_钱_基建内_暂时上班)
+            日销售记录 = [
+                日_钱_基建内,
+                日_书_基建内,
+                总_钱书比,
+                总_能练干员,
+                搓玉天数,
+                卖玉天数,
+                土量,
+                土量 * 5,
+            ]
+            for i in 日销售记录:
+                if i < 0:
+                    print("出错了")
+            self.练度列表_离谱.append(日销售记录)
+            if 日_钱书总数 < 100000 and abs(总_钱书比 - self.目标练度钱书比) < 0.005:
+                self.练度列表.append(日销售记录)
+
+        a = "日_钱_基建内, 日_书_基建内, 总_钱书比, 总_能练干员, 搓玉天数, 卖玉天数, 土量, 土量 * 5"
+        list2 = a.split(", ")
+
+        try:
+            self.练度列表排序 = sorted(self.练度列表, key=lambda x: x[-1])
+            for val1, val2 in zip(list2, self.练度列表排序[0]):
+                print(f"{val1}: {val2}")
+
+        except Exception:
+            print("出问题了")
+            练度列表排序 = sorted(self.练度列表_离谱, key=lambda x: x[0])
+            for val1, val2 in zip(list2, 练度列表排序[0]):
+                print(f"{val1}: {val2}")
+
+
+# Create an instance of the Calculator class
+calc = Calculator()
+calc.calculate()  # Perform calculations using the defined method

mower/tests/loadres_tests.py

@@ -0,0 +1,41 @@
+import unittest
+
+from mower.utils import path
+from mower.utils.image import res2path
+from mower.utils.path import get_path
+
+internal_dir = get_path("@install")
+install_dir = get_path("@install")
+
+
+class TestLogicExpression(unittest.TestCase):
+    def test_single(self):
+        res = res2path("infra_overview")
+        relative_path = str(res.relative_to(internal_dir))
+        self.assertEqual(relative_path, "mower/resources/infra_overview.png")
+
+    def test_single_hot(self):
+        res = res2path("@hot/inudi/banner")
+        relative_path = str(res.relative_to(install_dir))
+        self.assertEqual(relative_path, "tmp/hot_update/inudi/banner.png")
+
+    def test_single_jpg(self):
+        res = res2path("@hot/inudi/banner.jpg")
+        relative_path = str(res.relative_to(install_dir))
+        self.assertEqual(relative_path, "tmp/hot_update/inudi/banner.jpg")
+
+    def test_multi(self):
+        path.global_space = "/test/path"
+        res = res2path("infra_overview")
+        relative_path = str(res.relative_to(internal_dir))
+        self.assertEqual(relative_path, "mower/resources/infra_overview.png")
+
+    def test_multi_hot(self):
+        path.global_space = "/test/path"
+        res = res2path("@hot/inudi/banner")
+        relative_path = str(res.relative_to(install_dir))
+        self.assertEqual(relative_path, "tmp/hot_update/inudi/banner.png")
+
+
+if __name__ == "__main__":
+    unittest.main()

mower/tests/logic_expression_tests.py

@@ -0,0 +1,23 @@
+import unittest
+
+from mower.utils.logic_expression import get_logic_exp
+
+dict_minus = {"left": "114514", "operator": "-", "right": "1919810"}
+
+
+class TestLogicExpression(unittest.TestCase):
+    def test_single(self):
+        self.assertEqual(str(get_logic_exp({"left": "114514"})), "(114514  )")
+
+    def test_flat(self):
+        self.assertEqual(str(get_logic_exp(dict_minus)), "(114514 - 1919810)")
+
+    def test_nested(self):
+        self.assertEqual(
+            str(get_logic_exp({"left": "hi", "operator": "and", "right": dict_minus})),
+            "(hi and (114514 - 1919810))",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

mower/tests/recruit_tests.py

@@ -0,0 +1,24 @@
+import unittest
+
+from mower.solvers.recruit import RecruitSolver
+
+
+class TestRecruitCal(unittest.TestCase):
+    @unittest.mock.patch.object(RecruitSolver, "__init__", lambda x: None)
+    def setUp(self):
+        self.test_class = RecruitSolver()
+        self.test_class.recruit_order = [6, 5, 1, 4, 3, 2]
+
+    def test_recruit_cal_with_order_1(self):
+        recruit_tags = ["重装干员", "先锋干员", "高级资深干员", "支援", "支援机械"]
+        results = self.test_class.recruit_cal(recruit_tags)
+        print(f"顺序为 {self.test_class.recruit_order}")
+        print(results.keys())
+        for i in results:
+            for result in results[i]:
+                for agent in result["result"]:
+                    print(f"{i}  {result['tag']} {agent['name']}")
+
+
+if __name__ == "__main__":
+    unittest.main()

mower/tests/scheduler_task_tests.py

@@ -0,0 +1,415 @@
+import unittest
+from datetime import datetime, timedelta
+from unittest.mock import MagicMock, patch
+
+from mower.utils.operators import Operators
+from mower.utils.plan import Plan, PlanConfig, Room
+from mower.utils.scheduler_task import (
+    SchedulerTask,
+    TaskTypes,
+    check_dorm_ordering,
+    find_next_task,
+    scheduling,
+)
+
+with patch.dict("sys.modules", {"save_action_to_sqlite_decorator": MagicMock()}):
+    pass
+
+
+class TestScheduling(unittest.TestCase):
+    def test_adjust_two_orders(self):
+        # 测试两个跑单任务被拉开
+        task1 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:00", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 1"},
+            task_type=TaskTypes.RUN_ORDER,
+        )
+        task2 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:01", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 2"},
+        )
+        task3 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:02", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 3"},
+        )
+        task4 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:03", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 4"},
+            task_type=TaskTypes.RUN_ORDER,
+        )
+        task5 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:30", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 5"},
+        )
+        tasks = [task1, task2, task3, task4, task5]
+        res = scheduling(
+            tasks, time_now=datetime.strptime("2023-09-19 09:01", "%Y-%m-%d %H:%M")
+        )
+        # 返还的是应该拉开跑单的任务
+        self.assertNotEqual(res, None)
+
+    def test_adjust_two_orders_fia(self):
+        # 测试菲亚换班时间预设3分钟有效
+        task1 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:00", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 1"},
+        )
+        task2 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:01", "%Y-%m-%d %H:%M"),
+            task_plan={},
+            task_type=TaskTypes.FIAMMETTA,
+        )
+        task4 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:03", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 4"},
+            task_type=TaskTypes.RUN_ORDER,
+        )
+        task5 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:30", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 5"},
+        )
+        tasks = [task1, task2, task4, task5]
+        scheduling(
+            tasks, time_now=datetime.strptime("2023-09-19 10:00", "%Y-%m-%d %H:%M")
+        )
+        # 跑单任务被提前
+        self.assertEqual(tasks[0].type, TaskTypes.RUN_ORDER)
+
+    def test_adjust_time(self):
+        # 测试跑单任务被挤兑
+        task1 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:00", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 1"},
+            task_type=TaskTypes.RUN_ORDER,
+        )
+        task2 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:01", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 2"},
+        )
+        task3 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:02", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 3"},
+        )
+        task4 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:03", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 4"},
+            task_type=TaskTypes.RUN_ORDER,
+        )
+        task5 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:30", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 5"},
+        )
+        tasks = [task1, task2, task3, task4, task5]
+        res = scheduling(
+            tasks, time_now=datetime.strptime("2023-09-19 10:01", "%Y-%m-%d %H:%M")
+        )
+        # 其他任务会被移送至跑单任务以后
+        self.assertEqual(tasks[2].plan["task"], "Task 4")
+        self.assertEqual(res, None)
+
+    def test_find_next(self):
+        # 测试 方程有效
+        task1 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:00", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 1"},
+            task_type=TaskTypes.RUN_ORDER,
+            meta_data="room",
+        )
+        task4 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:03", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 4"},
+            task_type=TaskTypes.RUN_ORDER,
+            meta_data="room",
+        )
+        task5 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:30", "%Y-%m-%d %H:%M"),
+            task_plan={"task": "Task 5"},
+        )
+        tasks = [task1, task4, task5]
+        now = datetime.strptime("2023-09-19 10:00", "%Y-%m-%d %H:%M")
+        res1 = find_next_task(
+            tasks,
+            now + timedelta(minutes=5),
+            task_type=TaskTypes.RUN_ORDER,
+            meta_data="room",
+            compare_type=">",
+        )
+        res2 = find_next_task(
+            tasks,
+            now + timedelta(minutes=-60),
+            task_type=TaskTypes.RUN_ORDER,
+            meta_data="room",
+            compare_type=">",
+        )
+        self.assertEqual(res1, None)
+        self.assertNotEqual(res2, None)
+
+    def test_check_dorm_ordering_add_plan_1(self):
+        # 测试 方程有效
+        task1 = SchedulerTask(
+            time=datetime.now(),
+            task_plan={
+                "dormitory_1": ["Current", "Current", "夕", "Current", "Current"],
+                "central": ["麒麟R夜刀", "Current", "Current", "Current", "Current"],
+            },
+            task_type=TaskTypes.SHIFT_OFF,
+            meta_data="",
+        )
+        tasks = [task1]
+        op_data = self.init_opdata()
+        check_dorm_ordering(tasks, op_data)
+        # 生成额外宿舍任务
+        self.assertEqual(2, len(tasks))
+        # 验证第一个宿舍任务包含换班+宿舍任务
+        self.assertEqual(2, len(tasks[0].plan))
+        # 老plan含有见行者
+        self.assertEqual("见行者", tasks[1].plan["dormitory_1"][3])
+        # 假设换班任务执行完毕
+        del tasks[0]
+        # 重复执行不会生成新的
+        check_dorm_ordering(tasks, op_data)
+        self.assertEqual(1, len(tasks))
+        # 验证第二个任务仅仅包宿舍任务
+        self.assertEqual(1, len(tasks[0].plan))
+
+    def test_check_dorm_ordering_add_plan_2(self):
+        # 测试 方程有效
+        task1 = SchedulerTask(
+            time=datetime.now(),
+            task_plan={
+                "dormitory_1": ["Current", "Current", "夕", "Current", "Current"],
+                "central": ["麒麟R夜刀", "Current", "Current", "Current", "Current"],
+            },
+            task_type=TaskTypes.SHIFT_OFF,
+            meta_data="",
+        )
+        tasks = [task1]
+        op_data = self.init_opdata()
+        # 预设干员位置
+        op_data.operators["见行者"].current_index = -1
+        op_data.operators["见行者"].current_room = "meeting"
+        op_data.operators["麒麟R夜刀"].current_index = 3
+        op_data.operators["麒麟R夜刀"].current_room = "dormitory_1"
+        check_dorm_ordering(tasks, op_data)
+        # 生成额外宿舍任务
+        self.assertEqual(2, len(tasks))
+        # 验证第一个宿舍任务包含换班+宿舍任务
+        self.assertEqual(2, len(tasks[0].plan))
+        # 老plan不变
+        self.assertEqual("Current", tasks[1].plan["dormitory_1"][3])
+        # 假设换班任务执行完毕
+        del tasks[0]
+        # 重复执行不会生成新的
+        check_dorm_ordering(tasks, op_data)
+        self.assertEqual(1, len(tasks))
+        # 验证第二个任务仅仅包宿舍任务
+        self.assertEqual(1, len(tasks[0].plan))
+
+    def test_check_dorm_ordering_add_plan_3(self):
+        # 测试 宿舍4号位置已经吃到VIP的情况，安排新的高效干员去3号位置刷新VIP
+        task1 = SchedulerTask(
+            time=datetime.now(),
+            task_plan={
+                "dormitory_1": ["Current", "Current", "Current", "夕", "Current"],
+                "central": ["麒麟R夜刀", "Current", "Current", "Current", "Current"],
+            },
+            task_type=TaskTypes.SHIFT_OFF,
+            meta_data="",
+        )
+        tasks = [task1]
+        op_data = self.init_opdata()
+        # 预设干员位置
+        op_data.operators["红"].current_index = -1
+        op_data.operators["红"].current_room = "meeting"
+        op_data.operators["夕"].resting_priority = "low"
+        op_data.operators["焰尾"].current_index = 2
+        op_data.operators["焰尾"].current_room = "dormitory_1"
+        check_dorm_ordering(tasks, op_data)
+
+        # 如果非VIP位置被占用，则刷新
+        self.assertEqual(2, len(tasks))
+        # 验证第任务包含换班+宿舍任务
+        self.assertEqual(2, len(tasks[0].plan))
+        # 假设换班任务执行完毕
+        del tasks[0]
+        # 重复执行不会生成新的
+        check_dorm_ordering(tasks, op_data)
+        self.assertEqual(1, len(tasks))
+        # 验证第任务包宿舍+换班任务
+        self.assertEqual(1, len(tasks[0].plan))
+
+    def test_check_dorm_ordering_add_plan_4(self):
+        # 测试 方程有效
+        task1 = SchedulerTask(
+            time=datetime.now(),
+            task_plan={
+                "dormitory_1": ["Current", "Current", "夕", "Current", "Current"],
+                "central": ["麒麟R夜刀", "Current", "Current", "Current", "Current"],
+            },
+            task_type=TaskTypes.SHIFT_OFF,
+            meta_data="",
+        )
+        tasks = [task1]
+        op_data = self.init_opdata()
+        op_data.operators["玛恩纳"].current_room = ""
+        op_data.operators["玛恩纳"].current_index = -1
+        check_dorm_ordering(tasks, op_data)
+        # 生成额外宿舍任务
+        self.assertEqual(2, len(tasks))
+        # 验证第一个宿舍任务包含换班+宿舍任务
+        self.assertEqual(2, len(tasks[0].plan))
+        # 老plan含有见行者
+        self.assertEqual("见行者", tasks[1].plan["dormitory_1"][3])
+        # 假设换班任务执行完毕
+        del tasks[0]
+        # 重复执行不会生成新的
+        check_dorm_ordering(tasks, op_data)
+        self.assertEqual(1, len(tasks))
+        # 验证第二个任务仅仅包宿舍任务
+        self.assertEqual(1, len(tasks[0].plan))
+
+    def test_check_dorm_ordering_not_plan(self):
+        # 测试 如果当前已经有前置位VIP干员在吃单回，则不会新增任务
+        task1 = SchedulerTask(
+            time=datetime.now(),
+            task_plan={
+                "dormitory_1": ["Current", "Current", "Current", "夕", "令"],
+                "central": ["麒麟R夜刀", "Current", "Current", "Current", "火龙S黑角"],
+            },
+            task_type=TaskTypes.SHIFT_OFF,
+            meta_data="",
+        )
+        tasks = [task1]
+        op_data = self.init_opdata()
+        # 预设干员位置
+        op_data.operators["红"].current_index = -1
+        op_data.operators["夕"].resting_priority = "low"
+        op_data.operators["红"].current_room = "meeting"
+        op_data.operators["焰尾"].current_index = 2
+        op_data.operators["焰尾"].current_room = "dormitory_1"
+        check_dorm_ordering(tasks, op_data)
+
+        # 如果VIP位已经被占用，则不会生成新任务
+        self.assertEqual(1, len(tasks))
+        # 验证第任务包含换班+宿舍任务
+        self.assertEqual(2, len(tasks[0].plan))
+        # 重复执行不会生成新的
+        check_dorm_ordering(tasks, op_data)
+        self.assertEqual(1, len(tasks))
+        # 验证第任务包宿舍+换班任务
+        self.assertEqual(2, len(tasks[0].plan))
+
+    def test_check_dorm_ordering_not_plan2(self):
+        # 测试 如果当前已经有前置位VIP干员在吃单回，则不会新增任务
+        task1 = SchedulerTask(
+            time=datetime.now(),
+            task_plan={
+                "dormitory_1": ["Current", "Current", "Current", "夕", "Current"],
+                "central": ["麒麟R夜刀", "Current", "Current", "Current", "Current"],
+            },
+            task_type=TaskTypes.SHIFT_OFF,
+            meta_data="",
+        )
+        tasks = [task1]
+        op_data = self.init_opdata()
+        # 预设干员位置
+        op_data.operators["红"].current_index = 2
+        op_data.operators["红"].current_room = "dormitory_1"
+        op_data.operators["夕"].resting_priority = "low"
+        op_data.operators["红"].current_room = "meeting"
+        check_dorm_ordering(tasks, op_data)
+
+        # 如果VIP位已经被占用，则不会生成新任务
+        self.assertEqual(2, len(tasks))
+        # 验证第任务包含换班+宿舍任务
+        self.assertEqual(2, len(tasks[0].plan))
+        # 重复执行不会生成新的
+        check_dorm_ordering(tasks, op_data)
+        self.assertEqual(2, len(tasks))
+        # 验证第任务包宿舍+换班任务
+        self.assertEqual(2, len(tasks[0].plan))
+
+    def test_adjust_three_orders(self):
+        # 测试342跑单任务被拉开
+        task1 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:00", "%Y-%m-%d %H:%M"),
+            task_plan={"task1": "Task 1"},
+            task_type=TaskTypes.RUN_ORDER,
+            meta_data="task1",
+        )
+        task2 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:01", "%Y-%m-%d %H:%M"),
+            task_plan={"task2": "Task 2"},
+            task_type=TaskTypes.RUN_ORDER,
+            meta_data="task2",
+        )
+        task3 = SchedulerTask(
+            time=datetime.strptime("2023-09-19 10:02", "%Y-%m-%d %H:%M"),
+            task_plan={"task3": "Task 3"},
+            task_type=TaskTypes.RUN_ORDER,
+            meta_data="task3",
+        )
+        tasks = [task1, task2, task3]
+        res = scheduling(
+            tasks, time_now=datetime.strptime("2023-09-19 09:01", "%Y-%m-%d %H:%M")
+        )
+
+        while res is not None and res.meta_data == "task1":
+            task_time = res.time - timedelta(minutes=(2))
+            task = find_next_task(
+                tasks, task_type=TaskTypes.RUN_ORDER, meta_data="task1"
+            )
+            if task is not None:
+                task.time = task_time
+                res = scheduling(
+                    tasks,
+                    time_now=datetime.strptime("2023-09-19 09:03", "%Y-%m-%d %H:%M"),
+                )
+            else:
+                break
+        # 返还的是应该拉开跑单的任务
+        self.assertNotEqual(res, None)
+
+    def init_opdata(self):
+        agent_base_config = PlanConfig(
+            "稀音,黑键,伊内丝,承曦格雷伊", "稀音,柏喙,伊内丝", "见行者"
+        )
+        plan_config = {
+            "central": [
+                Room("夕", "", ["麒麟R夜刀"]),
+                Room("焰尾", "", ["凯尔希"]),
+                Room("森蚺", "", ["凯尔希"]),
+                Room("令", "", ["火龙S黑角"]),
+                Room("薇薇安娜", "", ["玛恩纳"]),
+            ],
+            "meeting": [
+                Room("伊内丝", "", ["陈", "红"]),
+                Room("见行者", "", ["陈", "红"]),
+            ],
+            "dormitory_1": [
+                Room("塑心", "", []),
+                Room("冰酿", "", []),
+                Room("Free", "", []),
+                Room("Free", "", []),
+                Room("Free", "", []),
+            ],
+        }
+        plan = {
+            "default_plan": Plan(plan_config, agent_base_config),
+            "backup_plans": [],
+        }
+        op_data = Operators(plan)
+        op_data.init_and_validate()
+        # 预设干员位置
+        op_data.operators["冰酿"].current_room = op_data.operators[
+            "塑心"
+        ].current_room = op_data.operators["见行者"].current_room = "dormitory_1"
+        op_data.operators["红"].current_room = op_data.operators[
+            "玛恩纳"
+        ].current_room = "dormitory_1"
+        op_data.operators["冰酿"].current_index = 0
+        op_data.operators["塑心"].current_index = 1
+        op_data.operators["红"].current_index = 2
+        op_data.operators["见行者"].current_index = 3
+        op_data.operators["玛恩纳"].current_index = 4
+        return op_data