def test_whenJiraIdIsZeroNameIsNone(self):
jiraStatus = mock()
mapObject = mock()
when(jiraStatus).status().thenReturn("")
status = TrackerItemStatus(jiraStatus, mapObject)
verify(mapObject, never).translateStatusTo(any(), any())
self.assertEqual(status.jira(), None)
def test_whenSeedingWithPivotalStatus(self):
pivotalStatus = "Started"
mapObject = mock()
status = TrackerItemStatus(pivotalStatus, apiObject=mapObject)
status.jira()
verify(mapObject).translateStatusTo('jira', pivotalStatus)
self.assertEqual(status.pivotal(), pivotalStatus)
def test_canSyncStatus(self):
statusA = TrackerItemStatus()
statusB = TrackerItemStatus()
item1 = TrackerItem().withStatus(statusA)
item2 = TrackerItem().withStatus(statusB)
item2.syncWith(item1)
syncedStatus = item2.status()
self.assertTrue(syncedStatus is statusA)
def test_inequalityOfStatused(self):
status = TrackerItemStatus()
garbage = "garbage"
pivotalStatus = "Started"
mapObject = mock()
statusNotEqual = TrackerItemStatus(pivotalStatus, apiObject=mapObject)
self.assertTrue(status != statusNotEqual)
self.assertFalse(status is statusNotEqual)
self.assertTrue(status != garbage)
def test_whenSeedingWithRemoteStatusForJira(self):
ticket = JiraTicket()
statusId = "1234"
closed = "Closed"
ticket.setStatus(statusId)
mapObject = mock()
when(mapObject).translateStatusTo('jiraStatusName', statusId).thenReturn([closed])
status = TrackerItemStatus(ticket, apiObject=mapObject)
status.pivotal()
inorder.verify(mapObject).translateStatusTo('jiraStatusName', statusId)
inorder.verify(mapObject).translateStatusTo('pivotal', closed)
self.assertEqual(status.jira(), [closed])
def test_canAdjustStateOfTicket(self):
tracker = self.jira_
Testing.mapStatuses(tracker)
item = jiraItemFactory(Env().get("jira", "project"),
"test_canAdjustStateOfTicket-1",
"can change the status of this ticket?")
Testing.putItemToTrackerAndChangeStatusTo("accepted", item, tracker)
item = next(tracker.items())
self.assertEqual(item.status(), TrackerItemStatus("accepted"))
def test_canMoveNewStateToInWork(self):
tracker = self.jira_
Testing.mapStatuses(tracker)
item = jiraItemFactory(Env().get("jira", "project"),
"test_canMoveNewStateToInWork-1",
"can change the status to In Work?")
Testing.putItemToTrackerAndChangeStatusTo("started", item, tracker)
item = next(tracker.items())
self.assertEqual(item.status(), TrackerItemStatus("started"))
def __init__(self, story=None, timezone=None):
'''
Constructor
'''
super(PivotalTrackerItem, self).__init__()
self.piecesToUpdate_ = []
self.story_ = defaultParameter(Story, story)
self._normalizeSummary(self.story_.GetName())
self._normalizeDescription(self.story_.GetDescription())
self.withStatus(TrackerItemStatus(self.story_.GetCurrentState()))
self.withType(self.story_.GetStoryType())
self.withRequestor(PivotalUser(self.story_.GetRequestedBy()))
self.withOwner(PivotalUser(self.story_.GetOwnedBy()))
self.timezone_ = timezone
self._determineIfNeedToUpdate(story)
def test_canSyncStatusToPivotalForExistingItems(self):
jira = self.jira_
pivotal = self.pivotal_
newJiraItem = jiraItemFactory(
Env().get("jira", "project"),
"test_canSyncStatusToPivotalForExistingItems",
"a test description")
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
jiraItem = next(jira.items())
status = TrackerItemStatus("accepted")
jiraItem.withStatus(status)
jira.update(jiraItem)
self.syncExistingItemFrom(jira, pivotal)
pivotalItem = next(pivotal.items())
self.assertEqual(pivotalItem.status(), status)
def __init__(self, ticket=None, timezone=None):
'''
Constructor
'''
super(JiraTrackerItem, self).__init__()
self.piecesToUpdate_ = []
self._addTicket(defaultParameter(JiraTicket, ticket))
self.withDescription(self.ticket_.description())
self.withSummary(self.ticket_.summary())
self.withStatus(TrackerItemStatus(self.ticket_))
self.withType("bug")
self.withRequestor(JiraUser(self.ticket_.reporter()))
self.withOwner(JiraUser(self.ticket_.assignee()))
self.timezone_ = timezone
self.piecesToUpdate_ = []
def test_canAddStatus(self):
PivotalToJiraStatusMap().addMapping(jira="Closed", pivotal="Accepted")
jiraStatus = JiraStatus(6, "Closed")
PivotalToJiraStatusMap().insert(jiraStatus)
item = JiraTrackerItem()
statusId = 6
ticket = JiraTicket()
ticket.setStatus(statusId)
status = TrackerItemStatus(ticket)
item.withStatus(status)
self.assertEqual(item.status(), status)
self.assertEqual(item.piecesToUpdate(), [
{
'id': "status",
'values': [
'',
]
},
])
PivotalToJiraStatusMap().reset()
def test_canAddStatus(self):
item = TrackerItem()
status = TrackerItemStatus()
item.withStatus(status)
self.assertEqual(item.status(), status)
def test_equalityOfStatuses(self):
status = TrackerItemStatus()
statusEqual = TrackerItemStatus()
self.assertTrue(status == statusEqual)
self.assertFalse(status is statusEqual)
def test_canCreateDefaultStatus(self):
status = TrackerItemStatus()
self.assertEqual(status.jira(), None)
self.assertEqual(status.pivotal(), None)
