Merge lp:~bjornt/lp2kanban/create-bug-lane into lp:~launchpad/lp2kanban/trunk

[Björn Tillenius]

Add a config option for specifying where new cards should be added.

When a card is added from a bug, the first lane was chosen. This
isn't always what you want, so with this change it's possible to
choose a specific lane.

I also took the opportunity to add tests for create_new_cards.
That's why the diff is quite large.

[Brad Crittenden (bac)]

This change looks good Bjorn. Thanks for the extra test coverage.

review: Approve (code)

=== modified file 'examples/config.ini'
--- examples/config.ini	2013-04-04 09:20:18 +0000
+++ examples/config.ini	2013-04-05 14:28:23 +0000
@@ -27,6 +27,10 @@
 # card type is used.
 #bug_to_card_type = Defect
 
+# Which lane cards created from bugs should be added to. If not set, the
+# first lane is used
+#bug_to_card_lane = Incoming
+
 # Lanes are assigned a "role" by looking for sublanes matching
 # values given here.  "Coding" will match all lanes which have
 # a title of "Coding", and "QA::Ready" will match all lanes

=== modified file 'src/lp2kanban/bugs2cards.py'
--- src/lp2kanban/bugs2cards.py	2013-04-04 09:20:18 +0000
+++ src/lp2kanban/bugs2cards.py	2013-04-05 14:28:23 +0000
@@ -363,7 +363,8 @@
                 return target_lane
         return None
 
-def create_new_cards(board, launchpad_project, bug_tag, cardtype_name=None):
+def create_new_cards(board, launchpad_project, bug_tag, cardtype_name=None,
+                     cardlane_path=None):
     """Create cards for bugs tagged in Launchpad.
 
     If a bug is tagged with the given tag, a new card will be created in
@@ -377,9 +378,12 @@
     kanban_bugtasks = launchpad_project.searchTasks(tags=[bug_tag])
     kanban_bugs = get_new_bugs(
         board, [bugtask.bug for bugtask in kanban_bugtasks])
-    next_lane = board.root_lane
-    while next_lane.child_lanes:
-        next_lane = next_lane.child_lanes[0]
+    if cardlane_path is not None:
+        next_lane = board.getLaneByPath(cardlane_path)
+    else:
+        next_lane = board.root_lane
+        while next_lane.child_lanes:
+            next_lane = next_lane.child_lanes[0]
     for bug in kanban_bugs:
         print "    Creating card for bug %s in %s." % (bug.id, next_lane.title)
         card = next_lane.addCard()
@@ -436,7 +440,8 @@
         for project in all_projects:
             print "   Creating new cards for %s:" % project.name
             create_new_cards(
-                board, project, new_bug_tag, bconf.get("bug_to_card_type"))
+                board, project, new_bug_tag, bconf.get("bug_to_card_type"),
+                bconf.get("bug_to_card_lane"))
     print "   Syncing cards:"
     should_move_cards = bconf.get('move_cards') == 'on'
     for card in board.getCardsWithExternalIds():

=== modified file 'src/lp2kanban/tests/common.py'
--- src/lp2kanban/tests/common.py	2013-04-04 11:51:48 +0000
+++ src/lp2kanban/tests/common.py	2013-04-05 14:28:23 +0000
@@ -8,16 +8,19 @@
 
 class FauxCardType:
 
-    def __init__(self):
-        self.id = 1
-        self.name = "Test"
-        self.is_default = True
+    def __init__(self, id=1, name='Test', is_default=True):
+        self.id = id
+        self.name = name
+        self.is_default = is_default
         self.ColourHex = "#000"
         self.IconPath = None
 
 
 class FauxBoard:
 
+    root_lane = None
+    _next_lane_id = 0
+
     def __init__(self, cards=None, users=None, users_by_id=None,
                  default_cardtype=None, is_archived=False):
         if cards is None:
@@ -25,12 +28,13 @@
         self.cards = cards
         self.users = users
         self.users_by_id = users_by_id
-        self.default_cardtype = default_cardtype or FauxCardType()
-        self.cardtypes = {1: FauxCardType()}
+        self.default_cardtype = default_cardtype or FauxCardType(id=1)
+        self.cardtypes = {self.default_cardtype.id: self.default_cardtype}
         self.is_archived = is_archived
         self._cards_with_description_annotations = set()
         self._cards_with_external_links = set()
         self.lanes = {}
+        self.root_lane = self.addLane('ROOT LANE')
 
     def getCardsWithDescriptionAnnotations(self):
         return self._cards_with_description_annotations
@@ -38,20 +42,33 @@
     def getCardsWithExternalLinks(self):
         return self._cards_with_external_links
 
+    def getLaneByPath(self, path):
+        for lane in self.lanes.values():
+            if lane.path == path:
+                return lane
+        return None
+
     def addLane(self, path):
-        lane = FauxLane(path, board=self)
-        self.lanes[path] = lane
+        lane = FauxLane(path, board=self, id=self._next_lane_id)
+        self._next_lane_id += 1
+        if self.root_lane is not None:
+            self.root_lane.child_lanes.append(lane)
+        self.lanes[lane.id] = lane
         return lane
 
 
 class FauxLane:
 
-    def __init__(self, path=None, id=None, type=None, board=None):
+    def __init__(self, path=None, title=None, id=None, type=None, board=None):
         self.id = id or 1
         self.type = type
         self.board = board or FauxBoard("Test")
         self.path = path
         self.next_lanes = None
+        self.child_lanes = []
+        if title is None:
+            title = path
+        self.title = title
 
     def getNextLanes(self):
         return self.next_lanes
@@ -62,7 +79,9 @@
         else:
             self.next_lanes.append(lane)
 
-    def addCard(self, card):
+    def addCard(self, card=None):
+        if card is None:
+            card = FauxCard()
         card.lane = self
         if self.board is not None:
             self.board.cards.append(card)
@@ -83,10 +102,11 @@
         self.external_system_name = external_system_name
         self.external_system_url = external_system_url
         self.moved_to = None
+        self.saved = False
 
     def save(self):
         """A no-op for compatibility."""
-        return
+        self.saved = True
 
     def move(self, target_lane):
         self.moved_to = target_lane

=== modified file 'src/lp2kanban/tests/test_bugs2cards.py'
--- src/lp2kanban/tests/test_bugs2cards.py	2013-04-04 11:51:48 +0000
+++ src/lp2kanban/tests/test_bugs2cards.py	2013-04-05 14:28:23 +0000
@@ -15,6 +15,7 @@
 
 from lp2kanban.bugs2cards import (
     CardStatus,
+    create_new_cards,
     find_card_target_lane_next,
     get_branch_info,
     get_bug_status,
@@ -34,6 +35,7 @@
 from lp2kanban.tests.common import (
     FauxBoard,
     FauxCard,
+    FauxCardType,
     FauxLane,
     )
 
@@ -254,10 +256,26 @@
         self.title = title
         self.description = description
         self.id = bug_id
+        self.saved = False
 
     def addTask(self, target, status='New', assignee=None):
-        self.bug_tasks_collection.append(
-            Record(target=target, status=status, assignee=assignee))
+        record = Record(target=target, status=status, assignee=assignee)
+        self.bug_tasks_collection.append(record)
+        return record
+
+    def lp_save(self):
+        self.saved = True
+
+
+class FauxBugTask:
+
+    def __init__(self, bug_id, target='faux-project', tags=None,
+                 title="Faux Bug", description="This is a faux bug."):
+        if tags is None:
+            tags = []
+        self.bug = FauxBug(
+            bug_id=bug_id, title=title, description=description, tags=tags)
+        self.record = self.bug.addTask(target)
 
 
 class BugStatusTest(unittest.TestCase):
@@ -557,6 +575,123 @@
         self.assertEqual([bugs[1]], list(get_new_bugs(board, bugs)))
 
 
+class FauxLaunchpadProject:
+
+    def __init__(self, bug_tasks=None):
+        if bug_tasks is None:
+            bug_tasks = []
+        self.bug_tasks = bug_tasks
+
+    def searchTasks(self, tags=None):
+        bug_tasks = self.bug_tasks
+        if tags is not None:
+            tags = set(tags)
+            bug_tasks = [
+                bug_task for bug_task in bug_tasks
+                if tags.intersection(bug_task.bug.tags) == tags]
+        return bug_tasks
+
+
+class CreateNewCardsTest(unittest.TestCase):
+
+    def test_no_bugs(self):
+        # If no bugs are found, no cards are created.
+        board = FauxBoard()
+        bug_lane = board.addLane('bugs')
+        project = FauxLaunchpadProject(bug_tasks=[])
+        create_new_cards(board, project, 'kanban')
+        self.assertEqual([], board.cards)
+
+    def test_new_bugs_card_added(self):
+        # If a new bug is found, a card is created for it, having the
+        # bug id, title and description saved.
+        board = FauxBoard()
+        bug_lane = board.addLane('bugs')
+        project = FauxLaunchpadProject(
+            bug_tasks=[FauxBugTask(
+                           bug_id=42, title='Test bug',
+                           description='Test bug description.',
+                           tags=['kanban'])])
+        create_new_cards(board, project, 'kanban')
+        [card] = board.cards
+        self.assertEqual('Test bug', card.title)
+        self.assertEqual('Test bug description.', card.description)
+        self.assertEqual('42', card.external_card_id)
+        self.assertEqual(board.default_cardtype.id, card.type_id)
+        self.assertTrue(card.saved)
+
+    def test_new_bugs_tag_removed(self):
+        # After a card is created from a bug, the bug tag is removed, so
+        # that having a lot of open bugs won't slow down the process.
+        board = FauxBoard()
+        bug_lane = board.addLane('bugs')
+        project = FauxLaunchpadProject(
+            bug_tasks=[FauxBugTask(
+                           bug_id=42, title='Test bug',
+                           description='Test bug description.',
+                           tags=['kanban'])])
+        create_new_cards(board, project, 'kanban')
+        [bug_task] = project.bug_tasks
+        self.assertEqual([], bug_task.bug.tags)
+        self.assertTrue(bug_task.bug.saved)
+
+    def test_new_bugs_tagged_only(self):
+        # Cards are created only for bugs having the bug tag that is
+        # passed in to create_new_cards().
+        board = FauxBoard()
+        bug_lane = board.addLane('bugs')
+        project = FauxLaunchpadProject(
+            bug_tasks=[FauxBugTask(
+                           bug_id=21, title='Tagged with other tag',
+                           tags=['sometag']),
+                       FauxBugTask(
+                           bug_id=42, title='Tagged with right tag',
+                           tags=['kanban']),
+                       FauxBugTask(
+                           bug_id=42, title='Tagged with no tags',
+                           tags=[])])
+        create_new_cards(board, project, 'kanban')
+        [card] = board.cards
+        self.assertEqual('Tagged with right tag', card.title)
+        self.assertEqual('42', card.external_card_id)
+
+    def test_new_bugs_custom_card_type(self):
+        # It's possible to specify which card type that the created card
+        # should have, instead of the default one.
+        board = FauxBoard()
+        bug_lane = board.addLane('bugs')
+        project = FauxLaunchpadProject(
+            bug_tasks=[FauxBugTask(
+                           bug_id=42, title='Test bug',
+                           description='Test bug description.',
+                           tags=['kanban'])])
+        feature_type = FauxCardType(id=2, name='Feature', is_default=False)
+        board.cardtypes[feature_type.id] = feature_type
+        create_new_cards(board, project, 'kanban', cardtype_name='Feature')
+        [card] = board.cards
+        self.assertEqual(feature_type.id, card.type_id)
+        self.assertTrue(card.saved)
+
+    def test_new_bugs_custom_card_lane(self):
+        # It's possible to specify to which lane the card should be
+        # added.
+        board = FauxBoard()
+        bug_lane = board.addLane('bugs')
+        bug_lane = board.addLane('incoming')
+        project = FauxLaunchpadProject(
+            bug_tasks=[FauxBugTask(
+                           bug_id=42, title='Test bug',
+                           description='Test bug description.',
+                           tags=['kanban'])])
+        feature_type = FauxCardType(id=2, name='Feature', is_default=False)
+        board.cardtypes[feature_type.id] = feature_type
+        create_new_cards(
+            board, project, 'kanban', cardtype_name='Feature',
+            cardlane_path='incoming')
+        [card] = board.cards
+        self.assertEqual('incoming', card.lane.path)
+
+
 class GroupsConfigTest(unittest.TestCase):
 
     def test_parse_group_conf_empty_file(self):
@@ -693,11 +828,11 @@
             "done_lanes": "done",
         }
         self.board = FauxBoard()
-        self.board.addLane("backlog")
+        self.backlog = self.board.addLane("backlog")
         self.board.addLane("coding")
-        self.board.addLane("review")
+        self.review = self.board.addLane("review")
         self.board.addLane("landing")
-        self.board.addLane("qa")
+        self.qa = self.board.addLane("qa")
         self.board.addLane("deploy")
         self.board.addLane("downtime")
         self.board.addLane("done")
@@ -705,51 +840,51 @@
 
     def test_coding(self):
         # CODING cards are moved to the coding lane.
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(card, CardStatus.CODING, self.bconf, [], self.lp_users)
         self.assertEqual("coding", card.moved_to.path)
 
     def test_review(self):
         # REVIEW cards are moved to the review lane.
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(card, CardStatus.REVIEW, self.bconf, [], self.lp_users)
         self.assertEqual("review", card.moved_to.path)
 
     def test_landing(self):
         # LANDING cards are moved to the landing lane.
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(card, CardStatus.LANDING, self.bconf, [], self.lp_users)
         self.assertEqual("landing", card.moved_to.path)
 
     def test_qa(self):
         # QA cards are moved to the qa lane.
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(card, CardStatus.QA, self.bconf, [], self.lp_users)
         self.assertEqual("qa", card.moved_to.path)
 
     def test_deploy(self):
         # DEPLOY cards are moved to the deploy lane.
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(card, CardStatus.DEPLOY, self.bconf, [], self.lp_users)
         self.assertEqual("deploy", card.moved_to.path)
 
     def test_downtime(self):
         # DOWNTIME_DEPLOY cards are moved to the downtime lane.
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(
             card, CardStatus.DOWNTIME_DEPLOY, self.bconf, [], self.lp_users)
         self.assertEqual("downtime", card.moved_to.path)
 
     def test_done(self):
         # DONE cards are moved to the done lane.
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(card, CardStatus.DONE, self.bconf, [], self.lp_users)
         self.assertEqual("done", card.moved_to.path)
 
     def test_backwards(self):
         # Cards can be moved backwards as well, e.g. go from QA to
         # CODING, if an issue is found.
-        card = self.board.lanes["qa"].addCard(FauxCard())
+        card = self.qa.addCard(FauxCard())
         move_card(card, CardStatus.CODING, self.bconf, [], self.lp_users)
         self.assertEqual("coding", card.moved_to.path)
 
@@ -758,7 +893,7 @@
         # an assignee, the card isn't moved.
         self.bconf["coding_lanes"] = "${group}::coding"
         self.board.addLane("test group::coding")
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         move_card(card, CardStatus.CODING, self.bconf, [], self.lp_users)
         self.assertEqual(None, card.moved_to)
 
@@ -768,7 +903,7 @@
         # group's lane.
         self.bconf["coding_lanes"] = "${group}::coding"
         self.board.addLane("test group::coding")
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         self.lp_users.lp_to_group["foo"] = "test group"
         move_card(
             card, CardStatus.CODING, self.bconf, [FauxPerson("foo")],
@@ -780,7 +915,7 @@
         # assignee that is not part of a group, the card isn't moved.
         self.bconf["coding_lanes"] = "${group}::coding"
         self.board.addLane("test group::coding")
-        card = self.board.lanes["backlog"].addCard(FauxCard())
+        card = self.backlog.addCard(FauxCard())
         self.lp_users.lp_to_group["foo"] = "test group"
         move_card(
             card, CardStatus.CODING, self.bconf, [FauxPerson("bar")],
@@ -790,7 +925,7 @@
     def test_manual_lanes(self):
         # Cards in a "manual" lane doesn't get moved by move_card().
         self.bconf["manual_lanes"] = "qa"
-        card = self.board.lanes["qa"].addCard(FauxCard())
+        card = self.qa.addCard(FauxCard())
         move_card(card, CardStatus.CODING, self.bconf, [], self.lp_users)
         self.assertEqual(None, card.moved_to)
 
@@ -798,9 +933,9 @@
         # Partial lane names can be specified in the "manual_lanes"
         # config, so that every group's QA lane can be set to manual,
         # for example.
-        self.board.addLane("dev::qa")
+        dev_qa = self.board.addLane("dev::qa")
         self.bconf["manual_lanes"] = "qa"
-        card = self.board.lanes["dev::qa"].addCard(FauxCard())
+        card = dev_qa.addCard(FauxCard())
         move_card(card, CardStatus.CODING, self.bconf, [], self.lp_users)
         self.assertEqual(None, card.moved_to)
 
@@ -808,8 +943,8 @@
         # Multiple "manual" lanes can be separated by comma in the
         # config.
         self.bconf["manual_lanes"] = "qa,review"
-        card1 = self.board.lanes["qa"].addCard(FauxCard())
-        card2 = self.board.lanes["review"].addCard(FauxCard())
+        card1 = self.qa.addCard(FauxCard())
+        card2 = self.review.addCard(FauxCard())
         move_card(card1, CardStatus.CODING, self.bconf, [], self.lp_users)
         move_card(card2, CardStatus.CODING, self.bconf, [], self.lp_users)
         self.assertEqual(None, card1.moved_to)
@@ -819,8 +954,8 @@
         # Whitespace is ignored when specifying multiple lanes in the
         # "manual_lanes" config.
         self.bconf["manual_lanes"] = " qa ,  review "
-        card1 = self.board.lanes["qa"].addCard(FauxCard())
-        card2 = self.board.lanes["review"].addCard(FauxCard())
+        card1 = self.qa.addCard(FauxCard())
+        card2 = self.review.addCard(FauxCard())
         move_card(card1, CardStatus.CODING, self.bconf, [], self.lp_users)
         move_card(card2, CardStatus.CODING, self.bconf, [], self.lp_users)
         self.assertEqual(None, card1.moved_to)