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)