Merge lp:~chad.smith/lp2kanban/kanban-cards-in-feature-owners-next into lp:lp2kanban

[Chad Smith]

Allow feature tags on bugs to get automatically created in the designated squad todo_lane

bugs2cards will now observe the todo_lane setting from the lp2kanban sync.ini. It allows specific people/groups to be a feature owner.

When a feature card is on the LKK board assigned to a specific kanban user and has an unique "feature tag X", any LP bugs tagged with "kanban" and the "feature tag X" will be moved into the todo_lane instead of the default bug_to_card_lane.

In landscape's LKK, our configuration will look like this:
https://pastebin.canonical.com/146880/

By default, bugs tagged kanban in Launchpad will end up in Backlog::Engineering

If a feature card tagged "openstack-roles" is assigned to Alberto on our kanban board, then any new LP bugs tagged "kanban openstack-roles" will automatically be but into the "Development::Epsilon::Next" lane instead of "Backlog::Engineering".

To Test:
make configs
./create_creds # logs your local lp2kanban branch in as you so you can modify our production LKK board
# Select "Update all" option in your browser to give edit rights to your lp2kanban user

# Feel free to play around with Support taskboards card in Beta::Doing lane, there are cards already in landed that can automatically be pulled into the feature taskboard if you drag it into the Ready for QA lane
# There is also a TEST TAGGED CARD which has the same tag "lp2kanban" as the feature card above and depending on where you place the TEST card, it either will be pulled into the taskboard, or will be ignored.

# You can also create new fake bugs against landscape tagged with kanban and some known feature tag.

# Run lp2kanban to update the board. Watch the board's activity stream for updates from "LR" Landscape robot
./bin/py src/lp2kanban/bugs2cards.py -c configs/sync.ini -b 'Landscape 2016'

[Benji York (benji)]

This branch looks good. I, for one, welcome our new kanban overlords.

review: Approve

[lp:~chad.smith/lp2kanban/kanban-cards-in-feature-owners-next]

130. By Chad Smith on 2016-01-08

rewrap some docstrings per review.

=== modified file 'src/lp2kanban/bugs2cards.py'
--- src/lp2kanban/bugs2cards.py	2015-12-22 20:17:50 +0000
+++ src/lp2kanban/bugs2cards.py	2016-01-08 16:41:46 +0000
@@ -96,12 +96,12 @@
     """Find Launchpad user accounts for board users and keep them cached.
 
     Provides three dicts:
-     * lp_to_kanban which uses Launchpad account names as keys and points
-       to LeankitUser records.
-     * kanban_to_lp which uses LeankitUser records as keys pointing to
-       actual Launchpad user records.
-     * lp_to_group which uses Launchpad account names as keys and points
-       to group names.
+     * lp_to_kanban which uses Launchpad account names as keys and points to
+       LeankitUser records.
+     * kanban_to_lp which uses LeankitUser.id as keys pointing to actual
+       Launchpad user records.
+     * lp_to_group which uses Launchpad account names as keys and points to
+       group names.
     """
     def __init__(self, kanban_to_lp=None, lp_to_kanban=None, lp_to_group=None):
         if kanban_to_lp is None:
@@ -124,7 +124,7 @@
                     " user %s." % (user,))
                 continue
             self.lp_to_kanban[lp_user.name] = board.users[user]
-            self.kanban_to_lp[board.users[user]] = lp_user
+            self.kanban_to_lp[board.users[user].id] = lp_user
         groups_config_file = config.get("groups_config_file")
         if groups_config_file:
             assert os.path.exists(groups_config_file), (
@@ -133,6 +133,31 @@
             groups_config.read(groups_config_file)
             self.lp_to_group.update(parse_groups_config(groups_config))
 
+        self.feature_lanes = {}
+        todo_lane =  config.get("todo_lane")
+        if not todo_lane:
+            return
+        for card in board.getFeatureCards():
+            if not card.tags:
+                print ("Info: feature card '%s' has no tags. New bugs tagged "
+                       "for this feature will not be moved to the proper "
+                       "todo_lane." % card.title)
+                continue
+            if "${group}" in todo_lane:
+                lp_user = self.kanban_to_lp.get(card.assigned_user_id)
+                if not lp_user:
+                    print ("Info: feature card '%s' has no assigned user. New "
+                           "bugs tagged for this feature will not be moved to "
+                           "the proper todo_lane." % card.title)
+                    continue
+                lane_path = todo_lane.replace(
+                    "${group}", self.lp_to_group[lp_user.name])
+            else:
+                lane_path = todo_lane
+            for tag in card.tags.split(","):
+                self.feature_lanes[tag.strip()] = board.getLaneByPath(
+                    lane_path)
+
 
 ORDERED_STATUSES = {'Rejected': 0,
                     'Work in progress': 0,
@@ -209,7 +234,7 @@
 
     @param feature_card: The feature LeankitCard to associate
     @param feature_bug: The Launchpad bug resource linked to this feature_card
-    @param card_type: only return cards this type: MP, Feature, Task, ...
+    @param card_type: only return cards this type: Branch, Feature, Task, ...
     """
     feature_tags = set()
     linked_cards = set()
@@ -477,8 +502,9 @@
                 return target_lane
         return None
 
+
 def create_new_cards(board, launchpad_project, bug_tag, cardtype_name=None,
-                     cardlane_path=None):
+                     cardlane_path=None, feature_lanes={}):
     """Create cards for bugs tagged in Launchpad.
 
     If a bug is tagged with the given tag, a new card will be created in
@@ -499,8 +525,16 @@
         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()
+        feature_lane = None
+        for tag in set(bug.tags).intersection(set(feature_lanes.keys())):
+            if tag != 'no-sync':
+                feature_lane = feature_lanes[tag]
+                break
+        if feature_lane:
+            card = feature_lane.addCard()
+        else:
+            card = next_lane.addCard()
+        print "    Creating card for bug %s in %s." % (bug.id, card.lane.title)
         card.title = bug.title
         card.description = bug.description
         card.external_card_id = str(bug.id)
@@ -558,7 +592,7 @@
             print "   Creating new cards for %s:" % project.name
             create_new_cards(
                 board, project, new_bug_tag, bconf.get("bug_to_card_type"),
-                bconf.get("bug_to_card_lane"))
+                bconf.get("bug_to_card_lane"), lp_users.feature_lanes)
     print "   Syncing cards:"
     # Process linked branch cards
     for card in board.getCardsWithExternalLinks(only_branches=True):

=== modified file 'src/lp2kanban/tests/common.py'
--- src/lp2kanban/tests/common.py	2015-12-21 21:28:40 +0000
+++ src/lp2kanban/tests/common.py	2016-01-08 16:41:46 +0000
@@ -34,7 +34,10 @@
         self._cards_with_description_annotations = set()
         self._cards_with_external_links = set()
         self._cards_with_branches = set()
-        self._feature_cards = set()
+        if feature_cards is None:
+            self._feature_cards = set()
+        else:
+            self._feature_cards = feature_cards
         self.lanes = {}
         self.root_lane = self.addLane('ROOT LANE')
 

=== modified file 'src/lp2kanban/tests/test_bugs2cards.py'
--- src/lp2kanban/tests/test_bugs2cards.py	2015-12-22 20:09:07 +0000
+++ src/lp2kanban/tests/test_bugs2cards.py	2016-01-08 16:41:46 +0000
@@ -664,13 +664,13 @@
 
     def test_get_cards_for_feature_can_filter_by_card_type(self):
         """Cards not matching card_type will not be returned."""
-        mp_card = FauxCard(tags="feature1")
-        mp_type = FauxCardType(id=2, name='MP', is_default=False)
-        mp_card.type = mp_type
-        self.board.cards.extend([mp_card])
+        branch_card = FauxCard(tags="feature1")
+        branch_type = FauxCardType(id=2, name='Branch', is_default=False)
+        branch_card.type = branch_type
+        self.board.cards.extend([branch_card])
         cards = get_cards_for_feature(
-            self.feature_card, self.feature_bug, card_type='MP')
-        self.assertItemsEqual([mp_card], cards)
+            self.feature_card, self.feature_bug, card_type='Branch')
+        self.assertItemsEqual([branch_card], cards)
       
 
 class FindLaneNextTest(unittest.TestCase):
@@ -936,6 +936,11 @@
 
 class LaunchpadUsersForBoardTest(unittest.TestCase):
 
+    def setUp(self):
+        self.branch_type = FauxCardType(id=1, name='Branch', is_default=False)
+        self.feature_type = FauxCardType(
+            id=2, name='Feature', is_default=False)
+
     def test_no_groups_config(self):
         # If the config doesn't contain an entry for a groups config,
         # ane empty dict is created for the group mapping.
@@ -966,9 +971,99 @@
         lp_users = LaunchpadUsersForBoard()
         lp_users.set_up_users(lp, board, config)
 
-        self.assertEqual(
-            {"foo": "Group 1", "bar": "Group 1", "baz": "Group 2"},
-            lp_users.lp_to_group)
+    def test_feature_lanes_unset_without_feature_cards(self):
+        # When no feature cards exist on a board, the feature_lanes dictionary
+        # is empty and todo_lane setting is not represented.
+        board = FauxBoard(users=[], feature_cards=[])
+        coding = board.addLane("dev::coding")
+        card = coding.addCard(FauxCard(tags=["sometag"]))
+        card.type = self.branch_type
+        lp = None
+        config = {"todo_lane": "my-Next-lane"}
+        lp_users = LaunchpadUsersForBoard()
+        lp_users.set_up_users(lp, board, config)
+        self.assertEqual({}, lp_users.feature_lanes)
+
+    def test_feature_lanes_unset_without_todo_lane_config(self):
+        # When feature cards are present, feature_lanes is empty when no
+        # todo_lane setting is in the config.
+        feature_card = FauxCard(tags=["sometag"])
+        feature_card.type = self.feature_type
+        board = FauxBoard(
+            users=[], cards=[feature_card], feature_cards=[feature_card])
+        coding_lane = board.addLane("dev::coding")
+        coding_lane.addCard(feature_card)
+        lp = None
+        config = {"todo_lane": ""}
+        lp_users = LaunchpadUsersForBoard()
+        lp_users.set_up_users(lp, board, config)
+        self.assertEqual({}, lp_users.feature_lanes)
+
+    def test_feature_lanes_set_with_feature_card_and_static_todo_lane(self):
+        # When a feature card is present and tagged and the config contains
+        # todo_lane which doesn't specify the ${group} variable, feature_lanes
+        # will be set for all tags.
+        feature_card = FauxCard(tags="sometag,anothertag")
+        feature_card.type = self.feature_type
+        board = FauxBoard(
+            users=[], cards=[feature_card], feature_cards=[feature_card])
+        coding_lane = board.addLane("dev::coding")
+        coding_lane.addCard(feature_card)
+        lp = None
+        config = {"todo_lane": "dev::coding"}
+        lp_users = LaunchpadUsersForBoard()
+        lp_users.set_up_users(lp, board, config)
+        self.assertEqual(
+            {"sometag": coding_lane, "anothertag": coding_lane}, 
+            lp_users.feature_lanes)
+
+    def test_feature_lanes_unset_with_group_todo_lane_and_no_assignee(self):
+        # When a feature card is present and tagged and the todo_lane
+        # in the config specifies the ${group} variable, 
+        # feature_lanes will be unset when there are no assigned users on the
+        # card.
+        feature_card = FauxCard(tags="sometag")
+        feature_card.type = self.feature_type
+        board = FauxBoard(
+            users=[], cards=[feature_card], feature_cards=[feature_card])
+        coding_lane = board.addLane("dev::group1::coding")
+        coding_lane.addCard(feature_card)
+        lp = None
+        config = {"todo_lane": "dev::${group}::coding"}
+        lp_users = LaunchpadUsersForBoard()
+        lp_users.set_up_users(lp, board, config)
+        self.assertIsNone(feature_card.assigned_user_id)
+        self.assertEqual({}, lp_users.feature_lanes)
+
+    def test_feature_lanes_set_with_group_todo_lane_and_assignee(self):
+        # When a feature card is present and tagged and the todo_lane
+        # in the config specifies the ${group} variable, 
+        # feature_lanes will be set when there are is an assigned user on the
+        # card.
+        feature_card = FauxCard(tags="sometag,anothertag")
+        feature_card.type = self.feature_type
+        feature_card.assigned_user_id = 1
+        groups_conf = '''
+            [Group 1]
+            members = User1,User2
+            [Group 2]
+            members = User3
+        '''
+        groups_file = tempfile.NamedTemporaryFile()
+        groups_file.write(dedent(groups_conf))
+        groups_file.flush()
+        board = FauxBoard(
+            users=[], cards=[feature_card], feature_cards=[feature_card])
+        coding_lane = board.addLane("dev::Group 1::coding")
+        coding_lane.addCard(feature_card)
+        lp = None
+        config = {"groups_config_file": groups_file.name,
+                  "todo_lane": "dev::${group}::coding"}
+        lp_users = LaunchpadUsersForBoard(kanban_to_lp={1:FauxPerson("User1")})
+        lp_users.set_up_users(lp, board, config)
+        self.assertEqual(
+            {"sometag": coding_lane, "anothertag": coding_lane}, 
+            lp_users.feature_lanes)
 
 
 class FauxPerson:
@@ -985,7 +1080,7 @@
         self.feature_bug = FauxBug(bug_id=123)
         self.feature_bug.linked_branches = [
             FauxBugBranch([], web_link=BRANCH_URL)]
-        self.mp_type = FauxCardType(id=1, name='MP', is_default=False)
+        self.branch_type = FauxCardType(id=1, name='Branch', is_default=False)
         self.feature_type = FauxCardType(
             id=2, name='Feature', is_default=False)
         self.feature_card.type = self.feature_type
@@ -1010,7 +1105,7 @@
         """
         linked_card = FauxCard(external_system_url=BRANCH_URL)
         linked_card.lane = self.coding
-        linked_card.type = self.mp_type
+        linked_card.type = self.branch_type
         self.board.cards.extend([linked_card])
         move_cards_to_feature_taskboard(
             self.feature_card, self.feature_bug, ["somelane", "otherlane"])
@@ -1023,10 +1118,10 @@
         """
         linked_card = FauxCard(external_system_url=BRANCH_URL)
         linked_card.lane = self.landing
-        linked_card.type = self.mp_type
+        linked_card.type = self.branch_type
         linked_card2 = FauxCard(external_system_url=BRANCH_URL)
         linked_card2.lane = self.deploy
-        linked_card2.type = self.mp_type
+        linked_card2.type = self.branch_type
         self.board.cards.extend([linked_card, linked_card2])
         move_cards_to_feature_taskboard(
             self.feature_card, self.feature_bug, ["landing", "deploy"])
@@ -1186,14 +1281,14 @@
 class MoveCardTest(unittest.TestCase):
 
     def setUp(self):
-        self.mp_type = FauxCardType(
-            id=1, name='MP', is_default=False)
+        self.branch_type = FauxCardType(
+            id=1, name='Branch', is_default=False)
 
     def test_should_move_not_if_disabled(self):
         board = FauxBoard(cards=[], is_archived=False)
         lane = FauxLane(board=board)
         card = FauxCard(lane=lane)
-        card.type = self.mp_type
+        card.type = self.branch_type
         board.cards.append(card)
         self.assertFalse(should_move_card(card, {'move_cards': 'off'}))
 
@@ -1201,7 +1296,7 @@
         board = FauxBoard(cards=[], is_archived=False)
         lane = FauxLane(board=board)
         card = FauxCard(lane=lane)
-        card.type = self.mp_type
+        card.type = self.branch_type
         board.cards.append(card)
         self.assertFalse(should_move_card(card, {}))
 
@@ -1209,7 +1304,7 @@
         board = FauxBoard(cards=[], is_archived=True)
         lane = FauxLane(board=board)
         card = FauxCard(lane=lane)
-        card.type = self.mp_type
+        card.type = self.branch_type
         board.cards.append(card)
         self.assertFalse(should_move_card(card, {'move_cards': 'on'}))
 
@@ -1217,7 +1312,7 @@
         board = FauxBoard(cards=[], is_archived=False)
         lane = FauxLane(board=board)
         card = FauxCard(lane=lane)
-        card.type = self.mp_type
+        card.type = self.branch_type
         board.cards.append(card)
         self.assertTrue(should_move_card(card, {'move_cards': 'on'}))