def test_whenSeedingWithUserForJira(self):
pivotalUser = "******"
jiraUser = "******"
mapObject = mock()
when(mapObject).translateUserTo('pivotal', jiraUser).thenReturn(pivotalUser)
userObject = JiraUser(jiraUser, apiObject=mapObject)
self.assertEqual(pivotalUser, userObject.pivotal())
self.assertEqual(jiraUser, userObject.jira())
def test_whenSeedingWithUserForJira(self):
pivotalUser = "******"
jiraUser = "******"
mapObject = mock()
when(mapObject).translateUserTo('pivotal',
jiraUser).thenReturn(pivotalUser)
userObject = JiraUser(jiraUser, apiObject=mapObject)
self.assertEqual(pivotalUser, userObject.pivotal())
self.assertEqual(jiraUser, userObject.jira())
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_doNotOverwriteWithUnknownReporter(self):
item = JiraTrackerItem()
withReporter = "reporter"
load = self.create_loader(JiraTrackerItem.withRequestor)
load(item, withReporter)
item.withRequestor(JiraUser(None))
self.assertEqual(withReporter, item.requestor().jira())
def test_doNotOverwriteWithUnknownOwner(self):
item = JiraTrackerItem()
withAssignee = "assignee"
load = self.create_loader(JiraTrackerItem.withOwner)
load(item, withAssignee)
item.withOwner(JiraUser(None))
self.assertEqual(withAssignee, item.owner().jira())
def getOtherUserAfterUpdatingJiraItem_(jira, pivotal, newJiraItem):
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
jiraItem = next(jira.items())
user = JiraUser(Env().get("jira", "otherUser"))
attributeSetter(jiraItem, user)
jira.update(jiraItem)
return user
def test_canOverwriteKnownAssignee(self):
item = JiraTrackerItem()
withAssignee = "assignee"
load = self.create_loader(JiraTrackerItem.withOwner)
load(item, withAssignee)
random = "me"
item.withOwner(JiraUser(random))
self.assertEqual(random, item.owner().jira())
def test_doNotOverwriteUnknownReporter(self):
item = JiraTrackerItem()
withReporter = "reporter"
load = self.create_loader(JiraTrackerItem.withRequestor)
load(item, withReporter)
PivotalToJiraUserMap().reset()
random = "me"
item.withRequestor(JiraUser(random))
self.assertNotEqual(random, item.requestor().jira())
self.assertEqual(withReporter, item.requestor().jira())
def test_doNotOverwriteUnknownAssignee(self):
PivotalToJiraUserMap().reset()
item = JiraTrackerItem()
withAssignee = "assignee"
load = self.create_loader(JiraTrackerItem.withOwner)
load(item, withAssignee)
PivotalToJiraUserMap().reset()
random = "me"
item.withOwner(JiraUser(random))
self.assertNotEqual(random, item.owner().jira())
self.assertEqual(withAssignee, item.owner().jira())
def test_canChangeAssignee(self):
item = JiraTrackerItem()
assignee = "me"
item.withOwner(JiraUser(assignee))
self.assertEqual(assignee, item.owner().jira())
self.assertEqual(assignee, item.underlying().assignee())
self.assertEqual(item.piecesToUpdate(), [{
'id': "assignee",
'values': [
assignee,
]
}])
def test_inequalityOfStatused(self):
pivotalUser = "******"
jiraUser = "******"
mapObject = mock()
when(mapObject).translateUserTo('pivotal',
jiraUser).thenReturn("garbage")
when(mapObject).translateUserTo('jira',
pivotalUser).thenReturn("garbage")
status = PivotalUser(pivotalUser, apiObject=mapObject)
statusEqual = JiraUser(jiraUser, apiObject=mapObject)
self.assertTrue(status != statusEqual)
self.assertTrue(status != "garbage")
def test_equalityOfStatuses(self):
pivotalUser = "******"
jiraUser = "******"
mapObject = mock()
when(mapObject).translateUserTo('pivotal',
jiraUser).thenReturn(pivotalUser)
when(mapObject).translateUserTo('jira',
pivotalUser).thenReturn(jiraUser)
status = PivotalUser(pivotalUser, apiObject=mapObject)
statusEqual = JiraUser(jiraUser, apiObject=mapObject)
self.assertTrue(status == statusEqual)
self.assertFalse(status is statusEqual)
self.assertTrue(status == status)
def test_canSetAssignee(self):
Testing.mapUsers()
tracker = self.jira_
item = jiraItemFactory(Env().get("jira", "project"),
"test_canSetAssignee-1", "can set assignee")
tracker.update(item)
item = next(tracker.items())
user = JiraUser(Env().get("jira", "otherUser"))
item.withOwner(user)
tracker.update(item)
item = next(tracker.items())
self.assertEqual(Env().get("jira", "otherUser"), item.owner().jira())
PivotalToJiraUserMap().reset()
def test_isUnknownWhenOneIsNone(self):
user = JiraUser("blah")
self.assertTrue(user.unknown())
user = PivotalUser("blah")
self.assertTrue(user.unknown())
def test_doNotAddDuplicateReporter(self):
testTicket = mock()
item = JiraTrackerItem(testTicket)
item.withRequestor(JiraUser(testTicket.reporter))
self.assertEqual(item.piecesToUpdate(), [])
def load_(item, withUser):
PivotalToJiraUserMap().reset()
PivotalToJiraUserMap().addMapping(withUser, "anything")
ofAttribute(item, JiraUser(withUser))
def test_isUnknownWhenOneIsNone(self):
user = JiraUser("blah")
self.assertTrue(user.unknown())
user = PivotalUser("blah")
self.assertTrue(user.unknown())
def test_doNotAddDuplicateAssignee(self):
testTicket = mock()
item = JiraTrackerItem(testTicket)
item.withOwner(JiraUser(testTicket.assignee))
self.assertEqual(item.piecesToUpdate(), [])
