def test_whenTicketNumberInCommentsOfOtherTickerTheRightSyncOccurs(self):
jira = self.jira_
pivotal = self.pivotal_
desiredSummary = "test_whenTicketNumberInCommentsOfOtherTickerTheRightSyncOccurs-1"
desiredDescription = "overwritten!"
newJiraItem = jiraItemFactory(Env().get("jira", "project"),
"to be overwritten", "also overwritten")
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
jiraItem = next(jira.items())
newJiraItem = jiraItemFactory(
Env().get("jira", "project"),
"test_whenTicketNumberInCommentsOfOtherTickerTheRightSyncOccurs-2",
"don't overwrite")
newJiraItem.addComment(TrackerItemComment(jiraItem.Id()))
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
for item in jira.items():
jiraItem = item
jiraItem.withDescription(desiredDescription)
jiraItem.withSummary(desiredSummary)
jira.update(jiraItem)
syncItem = TrackerSyncBy.syncingItem()
for item in jira.items():
syncItem(item, toTracker=pivotal)
for item in pivotal.items():
updatedPivotalItem = item
self.assertEqual(updatedPivotalItem.summary(), desiredSummary)
self.assertEqual(updatedPivotalItem.description(), desiredDescription)
pass
def test_canGetAssignee(self):
tracker = self.jira_
item = jiraItemFactory(Env().get("jira", "project"),
"test_canGetAssignee-1", "can get assignee")
tracker.update(item)
item = next(tracker.items())
self.assertEqual(Env().get("jira", "username"), item.owner().jira())
def test_canGetReporter(self):
tracker = self.jira_
item = jiraItemFactory(Env().get("jira", "project"),
"test_canGetReporter-1", "can get reporter")
tracker.update(item)
item = next(tracker.items())
self.assertEqual(Env().get("jira", "username"),
item.requestor().jira())
def tryToSyncUnknownUser(self, jira, pivotal):
PivotalToJiraUserMap().reset()
PivotalToJiraUserMap().addMapping(jira=Env().get("jira", "username"),
pivotal=Env().get(
"pivotal", "username"))
self.syncExistingItemFrom(jira, toTracker=pivotal)
self.syncExistingItemFrom(pivotal, toTracker=jira)
PivotalToJiraUserMap().addMapping(jira=Env().get("jira", "otherUser"),
pivotal=Env().get(
"pivotal", "otherUser"))
jiraItem = next(jira.items())
return jiraItem
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_canChangeRequestor(self):
tracker = self.pivotal_
item = PivotalTrackerItem().withSummary(
"test_canChangeRequestor-1").withDescription(
"can change the requestor of this ticket?")
tracker.update(item)
item = next(tracker.items())
newRequestor = PivotalUser(Env().get("pivotal", "otherUser"))
item.withRequestor(newRequestor)
tracker.update(item)
item = next(tracker.items())
self.assertTrue(
Env().get("pivotal", "otherUser") in item.requestor().pivotal())
def test_canChangeOwner(self):
tracker = self.pivotal_
item = PivotalTrackerItem().withSummary(
"test_canChangeOwner-1").withDescription(
"can change the owner of this ticket?").withType("bug")
Testing.putItemToTrackerAndChangeStatusTo("started", item, tracker)
item = next(tracker.items())
newOwner = PivotalUser(Env().get("pivotal", "otherUser"))
item.withOwner(newOwner)
tracker.update(item)
item = next(tracker.items())
self.assertTrue(
Env().get("pivotal", "otherUser") in item.owner().pivotal())
def test_doNotOverwriteJiraOwnerWhenUnassignedInPivotal(self):
jira = self.jira_
pivotal = self.pivotal_
newJiraItem = jiraItemFactory(
Env().get("jira", "project"),
"test_doNotOverwriteJiraOwnerWhenUnassignedInPivotal",
"a test description")
newJiraItem.withOwner(PivotalUser(Env().get("pivotal", "otherUser")))
getOtherUserAfterUpdatingJiraItem = self.create_getOtherUserAfterUpdatingJiraItem(
JiraTrackerItem.withRequestor)
user = getOtherUserAfterUpdatingJiraItem(jira, pivotal, newJiraItem)
updatePivotalAndSyncJiraItem = self.create_updatePivotalAndSyncJiraItem(
PivotalTrackerItem.withOwner)
jiraItem = updatePivotalAndSyncJiraItem(jira, pivotal)
self.assertEqual(jiraItem.owner(), user)
def test_canFilterTicketsReturnedFromJiraOnlyOneMatchIsFound(self):
tracker = self.jira_
item = jiraItemFactory(
Env().get("jira", "project"),
"test_canFilterTicketsReturnedFromJiraOnlyOneMatchIsFound",
"description")
tracker.update(item)
searchableSummary = "searchForMe"
forFilter = "summary ~ " + searchableSummary
item = jiraItemFactory(Env().get("jira", "project"), searchableSummary,
"description")
tracker.update(item)
item = tracker.items(forFilter)
self.assertEqual(next(item).summary(), searchableSummary)
self.assertRaises(StopIteration, next, item)
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 main(argv=None):
if argv is None:
argv = sys.argv[1:]
mapWorkflow()
mapUsers()
jira, pivotal = getTrackers()
jiraProjects, jiraBaseProject, jiraIssueLink = jiraDetails()
syncPivotalAndJira(jira, pivotal, jiraProjects, jiraBaseProject,
jiraIssueLink,
Env().get("skipSyncs"))
# print ("Reverse sync Pivotal Items:")
#
# reverseSyncFor = TrackerSyncBy.syncingItem(JiraIssue, andOmitPivotalTrackerCreatedComments, Direction=ReverseSync)
#
# for pivotalStory in pivotal.items("state:started,finished,delivered,accepted includedone:true"):
# aJiraKey = pivotalStory.jiraKey()
# if aJiraKey is not None:
# pivotalStory.withJiraUrl("https://jira.int.fusionio.com/browse/"+aJiraKey)
# reverseSyncFor(pivotalStory, toTracker=jira, fromTracker=pivotal)
print("DONE!")
return 0
def test_canUpdateItemAlreadyInJira(self):
tracker = self.jira_
item = jiraItemFactory(Env().get("jira", "project"),
"test_canUpdateItemAlreadyInJira-1",
"can update this?")
tracker.update(item)
Testing.canUpdateItemsIn(tracker, self)
def __init__(self, allowed, packages):
self.__allowed = allowed
self.packages = packages
self.__d = dict()
self.__done = set()
self.__registry = Registry()
self.env = Env()
super(API, self).__init__(self.__d)
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 test_canFilterTicketsReturnedFromJiraSoNoMatchesAreFound(self):
tracker = self.jira_
item = jiraItemFactory(
Env().get("jira", "project"),
"test_canFilterTicketsReturnedFromJiraSoNoMatchesAreFound",
"description")
tracker.update(item)
forFilter = "labels = WLK"
self.assertRaises(StopIteration, next, tracker.items(forFilter))
def test_canGetRequestor(self):
tracker = self.pivotal_
item = PivotalTrackerItem().withSummary(
"test_canGetRequestor-1").withDescription(
"can get the requestor of this ticket?")
tracker.update(item)
item = next(tracker.items())
self.assertTrue(
Env().get("pivotal", "username") in item.requestor().pivotal())
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_canAddStoryStoryToJira(self):
tracker = self.jira_
name = "test_canAddStoryStoryToPivotal"
description = "this is a test"
item = jiraItemFactory(Env().get("jira", "project"), name, description)
tracker.update(item)
story = next(tracker.items())
self.assertEqual(story.summary(), name)
self.assertEqual(story.description(), description)
def test_canAddCommentsToTicket(self):
tracker = self.jira_
item = jiraItemFactory(Env().get("jira", "project"),
"test_canAddCommentsToTicket-1",
"can comment on this?")
tracker.update(item)
aComment = Testing.addCommentToItemIn(tracker)
item = next(tracker.items())
self.assertEqual(item.comments()[0], aComment)
def test_newIssueInJiraIsCopiedToPivotal(self):
jira = self.jira_
pivotal = self.pivotal_
summary = "test_newIssueInJiraIsCopiedToPivotal"
newJiraItem = jiraItemFactory(Env().get("jira", "project"), summary,
"a test description")
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
pivotalItem = next(pivotal.items())
self.assertEqual(pivotalItem.summary(), summary)
self.assertEqual(pivotalItem.type(), 'bug')
def test_canRemoveAllStoriesFromJira(self):
tracker = self.jira_
item = jiraItemFactory(Env().get("jira", "project"),
"test_canRemoveAllStoriesFromJira-1",
"can delete this?")
tracker.update(item)
item.withSummary("test_canRemoveAllStoriesFromJira-2")
tracker.update(item)
tracker.deleteAllItems()
self.assertRaises(StopIteration, next, tracker.items())
def updatePivotalAndSyncJiraItem_(jira, pivotal):
item = next(pivotal.items())
attributeSetter(item, PivotalUser(Env().get("pivotal",
"username")))
pivotal.update(item)
item = next(pivotal.items())
attributeSetter(item, PivotalUser(None))
syncItem = TrackerSyncBy.syncingItem()
syncItem(item, jira)
return next(jira.items())
def test_issueInJiraAndInPivotalAreSyncable(self):
jira = self.jira_
pivotal = self.pivotal_
newJiraItem = jiraItemFactory(
Env().get("jira", "project"),
"test_issueInJiraAndInPivotalAreSyncable", "a test description")
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
jiraItem = next(jira.items())
pivotalItem = next(pivotal.items())
self.assertTrue(pivotalItem.canBeSyncedWith(jiraItem))
def test_20000PlusCharacterCommentsAreNotSyned(self):
jira = self.jira_
pivotal = self.pivotal_
newJiraItem = jiraItemFactory(
Env().get("jira", "project"),
"test_20000PlusCharacterCommentsAreNotSyned", "blah")
commentOnJira = TrackerItemComment(Testing.stringOfAsOfSize(20002))
newJiraItem.addComment(commentOnJira)
self.syncNewItemToPivotal(newJiraItem, jira, pivotal)
pivotalItem = next(pivotal.items())
self.assertEqual(len(pivotalItem.comments()), 0)
def test_doNotOverwriteJiraOwnerWhenUnknown(self):
jira = self.jira_
pivotal = self.pivotal_
newJiraItem = jiraItemFactory(
Env().get("jira", "project"),
"test_doNotOverwriteJiraOwnerWhenUnknown", "a test description")
getOtherUserAfterUpdatingJiraItem = self.create_getOtherUserAfterUpdatingJiraItem(
JiraTrackerItem.withOwner)
user = getOtherUserAfterUpdatingJiraItem(jira, pivotal, newJiraItem)
jiraItem = self.tryToSyncUnknownUser(jira, pivotal)
self.assertEqual(jiraItem.owner(), user)
def clone(self):
snapshot = self.to_snapshot(root_only=True, no_prevblocks=True)
env2 = Env(OverlayDB(self.env.db), self.env.config)
s = State.from_snapshot(snapshot, env2)
for param in STATE_DEFAULTS:
setattr(s, param, getattr(self, param))
s.prev_headers = self.prev_headers
for acct in self.cache.values():
assert not acct.touched
s.journal = copy.copy(self.journal)
s.cache = {}
return s
def __init__(self, root=b'', env=Env(), executing_on_head=False, **kwargs):
self.env = env
self.trie = SecureTrie(Trie(RefcountDB(self.db), root))
self.txindex = STATE_DEFAULTS['txindex']
self.block_number = STATE_DEFAULTS['block_number']
self.block_coinbase = STATE_DEFAULTS['block_coinbase']
self.timestamp = STATE_DEFAULTS['timestamp']
self.prev_headers = STATE_DEFAULTS['prev_headers']
self.journal = []
self.cache = {}
self.changed = {}
self.executing_on_head = executing_on_head
def __init__(self, genesis=None, env=None,
new_head_cb=None, reset_genesis=False, localtime=None, max_history=1000, **kwargs):
self.env = env or Env()
self.patricia = PatriciaState()
self.patricia.from_db() # TODO: test
# Initialize the state
if 'head_hash' in self.db: # new head tag
self.state = self.mk_poststate_of_blockhash(self.db.get('head_hash'))
self.state.executing_on_head = True
databaseLog.info('Initializing chain from saved head, #%d (%s)',self.state.prev_headers[0].number, encode_hex(self.state.prev_headers[0].hash))
elif genesis is None:
raise Exception("Need genesis decl!")
elif isinstance(genesis, State):
assert env is None
self.state = genesis
self.env = self.state.env
databaseLog.info('Initializing chain from provided state')
elif isinstance(genesis, dict):
databaseLog.info('Initializing chain from new state based on alloc')
diction = {}
self.state = state_from_genesis_declaration(
genesis, self.env, executing_on_head=True, pytricia=diction)
for key in diction:
self.patricia.set_value(str(key), str(diction[key]))
self.patricia.to_db()
reset_genesis = True
assert self.env.db == self.state.db
initialize(self.state)
self.new_head_cb = new_head_cb
if self.state.block_number == 0:
assert self.state.block_number == self.state.prev_headers[0].number
else:
assert self.state.block_number == self.state.prev_headers[0].number
if reset_genesis:
if isinstance(self.state.prev_headers[0], FakeHeader):
header = self.state.prev_headers[0].to_block_header()
else:
header = self.state.prev_headers[0]
self.genesis = Block(header)
self.state.prev_headers[0] = header
initialize_genesis_keys(self.state, self.genesis)
else:
self.genesis = self.get_block_by_number(0)
self.head_hash = self.state.prev_headers[0].hash
self.time_queue = []
self.parent_queue = {}
self.localtime = time.time() if localtime is None else localtime
self.max_history = max_history
def test_ticketUpdatedWhenNotChangedDoesNotModifyTicket(self):
tracker = self.jira_
item = jiraItemFactory(
Env().get("jira", "project"),
"test_ticketUpdatedWhenNotChangedDoesNotModifyTicket",
"description")
tracker.update(item)
itemInJira = next(tracker.items())
itemInJira.syncWith(itemInJira)
tracker.update(itemInJira)
updatedItem = next(tracker.items())
self.assertEquals(itemInJira.updatedAt(), updatedItem.updatedAt())
def test_canDownloadStoriesFromJira(self):
tracker = self.jira_
item = jiraItemFactory(Env().get("jira", "project"),
"test_canDownloadStoriesFromJira-1",
"A test description")
tracker.update(item)
item.withSummary("test_canDownloadStoriesFromJira-2")
tracker.update(item)
storiesIterator = tracker.items()
next(storiesIterator)
next(storiesIterator)
self.assertRaises(StopIteration, next, storiesIterator)
