fix: ensure create_column_transaction always returns a list for value to maintain API consistency

Author: awayfromtty

conduit/client/maniphest.py

@@ -338,15 +338,15 @@ def create_column_transaction(
         after_phids: Optional[List[PHID]] = None,
     ) -> ManiphestTaskTransaction:
         """Create a transaction to move task to a workboard column."""
-        if before_phids or after_phids:
-            column_position = {"columnPHID": column_phid}
-            if before_phids:
-                column_position["beforePHIDs"] = before_phids
-            if after_phids:
-                column_position["afterPHIDs"] = after_phids
-            return {"type": "column", "value": [column_position]}
-        else:
-            return {"type": "column", "value": column_phid}
+        column_position = {"columnPHID": column_phid}
+
+        if before_phids:
+            column_position["beforePHIDs"] = before_phids
+        if after_phids:
+            column_position["afterPHIDs"] = after_phids
+
+        # Always return value as a list to maintain API consistency
+        return {"type": "column", "value": [column_position]}
 
     @staticmethod
     def create_space_transaction(space_phid: PHID) -> ManiphestTaskTransaction:

conduit/client/tests/test_maniphest.py

@@ -339,3 +339,235 @@ def test_search_helper_methods(self):
             # Verify all returned tasks are authored by current user
             for task in results["data"]:
                 self.assertEqual(task["fields"]["authorPHID"], self.user["phid"])
+
+    def test_create_column_transaction_type_consistency(self):
+        """
+        测试 create_column_transaction 方法始终返回正确的列表格式。
+
+        这个测试专门针对修复的问题：
+        API Error: Exception when processing transaction of type "column":
+        Error while reading "value": Expected a list, but value is not a list.
+        """
+        test_column_phid = "PHID-PCOL-TESTCOLUMN"
+        test_before_phid = "PHID-TASK-BEFORE"
+        test_after_phid = "PHID-TASK-AFTER"
+
+        with self.subTest("Simple column transaction (no positioning)"):
+            """测试简单列事务始终返回列表格式"""
+            transaction = self.cli.create_column_transaction(
+                column_phid=test_column_phid
+            )
+
+            # 验证基本结构
+            self.assertEqual(transaction["type"], "column")
+            self.assertIsInstance(
+                transaction["value"],
+                list,
+                "简单列事务的 value 必须是列表格式，不能是字符串",
+            )
+            self.assertEqual(len(transaction["value"]), 1, "列表应该只包含一个元素")
+
+            # 验证列位置对象
+            column_position = transaction["value"][0]
+            self.assertIsInstance(column_position, dict, "列表元素应该是字典格式")
+            self.assertEqual(
+                column_position["columnPHID"],
+                test_column_phid,
+                "columnPHID 应该正确设置",
+            )
+
+            # 验证没有定位字段
+            self.assertNotIn(
+                "beforePHIDs", column_position, "简单列事务不应该包含 beforePHIDs"
+            )
+            self.assertNotIn(
+                "afterPHIDs", column_position, "简单列事务不应该包含 afterPHIDs"
+            )
+
+        with self.subTest("Column transaction with before_phids only"):
+            """测试只包含 before_phids 的列事务"""
+            transaction = self.cli.create_column_transaction(
+                column_phid=test_column_phid, before_phids=[test_before_phid]
+            )
+
+            # 验证基本结构
+            self.assertEqual(transaction["type"], "column")
+            self.assertIsInstance(
+                transaction["value"], list, "带定位的列事务也必须是列表格式"
+            )
+            self.assertEqual(len(transaction["value"]), 1, "列表应该只包含一个元素")
+
+            # 验证列位置对象
+            column_position = transaction["value"][0]
+            self.assertEqual(column_position["columnPHID"], test_column_phid)
+            self.assertIn("beforePHIDs", column_position, "应该包含 beforePHIDs")
+            self.assertEqual(
+                column_position["beforePHIDs"],
+                [test_before_phid],
+                "beforePHIDs 应该正确设置",
+            )
+            self.assertNotIn("afterPHIDs", column_position, "不应该包含 afterPHIDs")
+
+        with self.subTest("Column transaction with after_phids only"):
+            """测试只包含 after_phids 的列事务"""
+            transaction = self.cli.create_column_transaction(
+                column_phid=test_column_phid, after_phids=[test_after_phid]
+            )
+
+            # 验证基本结构
+            self.assertEqual(transaction["type"], "column")
+            self.assertIsInstance(
+                transaction["value"], list, "带定位的列事务也必须是列表格式"
+            )
+            self.assertEqual(len(transaction["value"]), 1, "列表应该只包含一个元素")
+
+            # 验证列位置对象
+            column_position = transaction["value"][0]
+            self.assertEqual(column_position["columnPHID"], test_column_phid)
+            self.assertNotIn("beforePHIDs", column_position, "不应该包含 beforePHIDs")
+            self.assertIn("afterPHIDs", column_position, "应该包含 afterPHIDs")
+            self.assertEqual(
+                column_position["afterPHIDs"],
+                [test_after_phid],
+                "afterPHIDs 应该正确设置",
+            )
+
+        with self.subTest("Column transaction with both before_phids and after_phids"):
+            """测试同时包含 before_phids 和 after_phids 的列事务"""
+            transaction = self.cli.create_column_transaction(
+                column_phid=test_column_phid,
+                before_phids=[test_before_phid],
+                after_phids=[test_after_phid],
+            )
+
+            # 验证基本结构
+            self.assertEqual(transaction["type"], "column")
+            self.assertIsInstance(
+                transaction["value"], list, "完整定位的列事务也必须是列表格式"
+            )
+            self.assertEqual(len(transaction["value"]), 1, "列表应该只包含一个元素")
+
+            # 验证列位置对象
+            column_position = transaction["value"][0]
+            self.assertEqual(column_position["columnPHID"], test_column_phid)
+            self.assertIn("beforePHIDs", column_position, "应该包含 beforePHIDs")
+            self.assertIn("afterPHIDs", column_position, "应该包含 afterPHIDs")
+            self.assertEqual(
+                column_position["beforePHIDs"],
+                [test_before_phid],
+                "beforePHIDs 应该正确设置",
+            )
+            self.assertEqual(
+                column_position["afterPHIDs"],
+                [test_after_phid],
+                "afterPHIDs 应该正确设置",
+            )
+
+        with self.subTest("Column transaction with multiple positioning PHIDs"):
+            """测试多个定位 PHID 的列事务"""
+            multiple_before = ["PHID-TASK-BEFORE1", "PHID-TASK-BEFORE2"]
+            multiple_after = ["PHID-TASK-AFTER1", "PHID-TASK-AFTER2"]
+
+            transaction = self.cli.create_column_transaction(
+                column_phid=test_column_phid,
+                before_phids=multiple_before,
+                after_phids=multiple_after,
+            )
+
+            # 验证基本结构
+            self.assertEqual(transaction["type"], "column")
+            self.assertIsInstance(transaction["value"], list)
+            self.assertEqual(len(transaction["value"]), 1)
+
+            # 验证列位置对象
+            column_position = transaction["value"][0]
+            self.assertEqual(column_position["columnPHID"], test_column_phid)
+            self.assertEqual(
+                column_position["beforePHIDs"],
+                multiple_before,
+                "应该支持多个 beforePHIDs",
+            )
+            self.assertEqual(
+                column_position["afterPHIDs"], multiple_after, "应该支持多个 afterPHIDs"
+            )
+
+        with self.subTest("Type consistency across all variants"):
+            """验证所有变体都返回相同的基本类型结构"""
+            variants = [
+                # 简单列事务
+                self.cli.create_column_transaction(column_phid=test_column_phid),
+                # 只包含 before
+                self.cli.create_column_transaction(
+                    column_phid=test_column_phid, before_phids=[test_before_phid]
+                ),
+                # 只包含 after
+                self.cli.create_column_transaction(
+                    column_phid=test_column_phid, after_phids=[test_after_phid]
+                ),
+                # 包含两者
+                self.cli.create_column_transaction(
+                    column_phid=test_column_phid,
+                    before_phids=[test_before_phid],
+                    after_phids=[test_after_phid],
+                ),
+            ]
+
+            for i, transaction in enumerate(variants):
+                with self.subTest(variant=i):
+                    # 所有变体都应该有相同的基本类型结构
+                    self.assertEqual(
+                        transaction["type"], "column", f"变体 {i} 的类型应该是 'column'"
+                    )
+                    self.assertIsInstance(
+                        transaction["value"], list, f"变体 {i} 的 value 必须是列表"
+                    )
+                    self.assertEqual(
+                        len(transaction["value"]),
+                        1,
+                        f"变体 {i} 的列表应该只包含一个元素",
+                    )
+                    self.assertIsInstance(
+                        transaction["value"][0], dict, f"变体 {i} 的列表元素应该是字典"
+                    )
+                    self.assertEqual(
+                        transaction["value"][0]["columnPHID"],
+                        test_column_phid,
+                        f"变体 {i} 的 columnPHID 应该正确",
+                    )
+
+    def test_column_transaction_prevents_api_error(self):
+        """
+        测试修复后的列事务不会导致 "Expected a list" API 错误。
+
+        这是一个回归测试，确保之前修复的问题不会重新出现。
+        """
+        test_column_phid = "PHID-PCOL-TESTCOLUMN"
+
+        # 模拟用户原始调用场景
+        transaction = self.cli.create_column_transaction(column_phid=test_column_phid)
+
+        # 验证事务格式符合 Phabricator API 要求
+        self.assertEqual(transaction["type"], "column")
+
+        # 关键验证：value 必须是列表，这是导致原始错误的原因
+        self.assertIsInstance(
+            transaction["value"],
+            list,
+            "修复后的列事务必须返回列表格式以避免 'Expected a list' 错误",
+        )
+
+        # 验证列表内容
+        self.assertGreater(len(transaction["value"]), 0, "列表不能为空")
+        self.assertIsInstance(
+            transaction["value"][0], dict, "列表元素必须是包含列位置信息的字典"
+        )
+
+        # 验证列位置信息结构
+        column_position = transaction["value"][0]
+        self.assertIn("columnPHID", column_position, "必须包含 columnPHID 字段")
+        self.assertEqual(
+            column_position["columnPHID"], test_column_phid, "columnPHID 值必须正确"
+        )
+
+        # 这个测试确保了修复的有效性，防止回归
+        # 如果这里失败，说明 "Expected a list, but value is not a list" 错误可能会重新出现

conduit/client/tests/test_workboard.py

@@ -91,7 +91,10 @@ def test_column_transaction_creation(self):
             column_phid="PHID-PCOL-EXAMPLE"
         )
         self.assertEqual(simple_tx["type"], "column")
-        self.assertEqual(simple_tx["value"], "PHID-PCOL-EXAMPLE")
+        # After fix: value should always be a list containing column position dict
+        self.assertIsInstance(simple_tx["value"], list)
+        self.assertEqual(len(simple_tx["value"]), 1)
+        self.assertEqual(simple_tx["value"][0]["columnPHID"], "PHID-PCOL-EXAMPLE")
 
         # Test 2: Column transaction with positioning
         positioned_tx = self.maniphest_client.create_column_transaction(
@@ -117,13 +120,21 @@ def test_column_transaction_creation(self):
         )
         self.assertEqual(after_only_tx["type"], "column")
         self.assertIsInstance(after_only_tx["value"], list)
+        self.assertEqual(len(after_only_tx["value"]), 1)
+        self.assertEqual(after_only_tx["value"][0]["columnPHID"], "PHID-PCOL-EXAMPLE")
+        self.assertEqual(after_only_tx["value"][0]["afterPHIDs"], ["PHID-TASK-AFTER1"])
 
         # Test with just before_phids
         before_only_tx = self.maniphest_client.create_column_transaction(
             column_phid="PHID-PCOL-EXAMPLE", before_phids=["PHID-TASK-BEFORE1"]
         )
         self.assertEqual(before_only_tx["type"], "column")
         self.assertIsInstance(before_only_tx["value"], list)
+        self.assertEqual(len(before_only_tx["value"]), 1)
+        self.assertEqual(before_only_tx["value"][0]["columnPHID"], "PHID-PCOL-EXAMPLE")
+        self.assertEqual(
+            before_only_tx["value"][0]["beforePHIDs"], ["PHID-TASK-BEFORE1"]
+        )
 
     def test_workboard_data_structures(self):
         """Test Workboard-related data structures and API responses."""