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_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 pit(env: Env, actors: List[Env.Actor], render: bool = False): s, ag_id = env.init_state() current_actor_ = actors[ag_id] done = False env_output = action = None while not done: if render: print(f'agent {env.agent_symbols[ag_id]} turn') # render_(s) action = current_actor_(s, render) env_output = env.model(s, action, ag_id, render=False) current_actor_ = actors[env_output.next_agent_id] ag_id = env_output.next_agent_id done = env_output.done if not done: s = env_output.next_state if render: print("done") env.state_utils.render_(s) print(action) env.state_utils.render_(env_output.next_state) print(env_output.rewards) print(env_output.message) return env_output.rewards
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_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 mapWorkflow(): jiraToPivotalStatuses = Env().get("jiraToPivotalStatuses") for jira in jiraToPivotalStatuses.keys(): if jira is not "transitions": PivotalToJiraStatusMap().addMapping(jira, jiraToPivotalStatuses[jira]) try: transitions = jiraToPivotalStatuses["transitions"] for transition in transitions.keys(): PivotalToJiraStatusMap().addMapping(transition, transitionFrom=transitions[transition]) except KeyError: return
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 mapStatuses(tracker): jiraToPivotalStatuses = Env().get("jiraToPivotalStatuses") for jira in jiraToPivotalStatuses.keys(): if jira is not "transitions": PivotalToJiraStatusMap().addMapping(jira, jiraToPivotalStatuses[jira]) try: transitions = jiraToPivotalStatuses["transitions"] for transition in transitions.keys(): PivotalToJiraStatusMap().addMapping(transition, transitionFrom=transitions[transition]) except KeyError: pass PivotalToJiraStatusMap().insert(tracker.getAvailableStatuses())
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 mapWorkflow(): jiraToPivotalStatuses = Env().get("jiraToPivotalStatuses") for jira in jiraToPivotalStatuses.keys(): if jira is not "transitions": PivotalToJiraStatusMap().addMapping(jira, jiraToPivotalStatuses[jira]) try: transitions = jiraToPivotalStatuses["transitions"] for transition in transitions.keys(): PivotalToJiraStatusMap().addMapping( transition, transitionFrom=transitions[transition]) except KeyError: return
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 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_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 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_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_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_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_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_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_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_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_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 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_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 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 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 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 mapUsers(): jiraToPivotalUsers = Env().get("jiraToPivotalUsers") for jira in jiraToPivotalUsers.keys(): PivotalToJiraUserMap().addMapping(jira, jiraToPivotalUsers[jira])
class API(ReadOnly): """ Dynamic API object through which `Plugin` instances are accessed. """ register = Registrar() def __init__(self): super(API, self).__init__() self.__plugins = {} self.__done = set() self.env = Env() @property def bases(self): raise NotImplementedError @property def modules(self): raise NotImplementedError def __len__(self): """ Return the number of plugin namespaces in this API object. """ return len(self.bases) def __iter__(self): """ Iterate (in ascending order) through plugin namespace names. """ return (base.__name__ for base in self.bases) def __contains__(self, name): """ Return True if this API object contains plugin namespace ``name``. :param name: The plugin namespace name to test for membership. """ return name in set(self) def __getitem__(self, name): """ Return the plugin namespace corresponding to ``name``. :param name: The name of the plugin namespace you wish to retrieve. """ if name in self: try: return getattr(self, name) except AttributeError: pass raise KeyError(name) def __call__(self): """ Iterate (in ascending order by name) through plugin namespaces. """ for name in self: try: yield getattr(self, name) except AttributeError: raise KeyError(name) def is_production_mode(self): """ If the object has self.env.mode defined and that mode is production return True, otherwise return False. """ return getattr(self.env, 'mode', None) == 'production' def __doing(self, name): if name in self.__done: raise StandardError( '%s.%s() already called' % (self.__class__.__name__, name) ) self.__done.add(name) def __do_if_not_done(self, name): if name not in self.__done: getattr(self, name)() def isdone(self, name): return name in self.__done def bootstrap(self, parser=None, **overrides): """ Initialize environment variables and logging. """ self.__doing('bootstrap') self.log_mgr = log_mgr log = log_mgr.root_logger self.log = log self.env._bootstrap(**overrides) self.env._finalize_core(**dict(DEFAULT_CONFIG)) # Add the argument parser if not parser: parser = self.build_global_parser() self.parser = parser # If logging has already been configured somewhere else (like in the # installer), don't add handlers or change levels: if log_mgr.configure_state != 'default' or self.env.validate_api: return log_mgr.default_level = 'info' log_mgr.configure_from_env(self.env, configure_state='api') # Add stderr handler: level = 'info' if self.env.debug: level = 'debug' else: if self.env.context == 'cli': if self.env.verbose > 0: level = 'info' else: level = 'warning' if log_mgr.handlers.has_key('console'): log_mgr.remove_handler('console') log_mgr.create_log_handlers([dict(name='console', stream=sys.stderr, level=level, format=LOGGING_FORMAT_STDERR)]) # Add file handler: if self.env.mode in ('dummy', 'unit_test'): return # But not if in unit-test mode if self.env.log is None: return log_dir = path.dirname(self.env.log) if not path.isdir(log_dir): try: os.makedirs(log_dir) except OSError: log.error('Could not create log_dir %r', log_dir) return level = 'info' if self.env.debug: level = 'debug' try: log_mgr.create_log_handlers([dict(name='file', filename=self.env.log, level=level, format=LOGGING_FORMAT_FILE)]) except IOError, e: log.error('Cannot open log file %r: %s', self.env.log, e) return
def __init__(self): super(API, self).__init__() self.__plugins = {} self.__done = set() self.env = Env()
def __init__(self, *allowed): self.__d = dict() self.__done = set() self.register = Registrar(*allowed) self.env = Env() super(API, self).__init__(self.__d)
class API(DictProxy): """ Dynamic API object through which `Plugin` instances are accessed. """ 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 register(self, klass, override=False): """ Register the plugin ``klass``. :param klass: A subclass of `Plugin` to attempt to register. :param override: If true, override an already registered plugin. """ self.__registry(override)(klass) def __doing(self, name): if name in self.__done: raise StandardError( '%s.%s() already called' % (self.__class__.__name__, name) ) self.__done.add(name) def __do_if_not_done(self, name): if name not in self.__done: getattr(self, name)() def isdone(self, name): return name in self.__done def bootstrap(self, parser=None, **overrides): """ Initialize environment variables and logging. """ self.__doing('bootstrap') self.env._bootstrap(**overrides) self.env._finalize_core(**dict(DEFAULT_CONFIG)) object.__setattr__(self, 'log_mgr', log_mgr) log = log_mgr.root_logger object.__setattr__(self, 'log', log) # Add the argument parser if not parser: parser = self.build_global_parser() object.__setattr__(self, 'parser', parser) # If logging has already been configured somewhere else (like in the # installer), don't add handlers or change levels: if log_mgr.configure_state != 'default' or self.env.validate_api: return log_mgr.default_level = 'info' log_mgr.configure_from_env(self.env, configure_state='api') # Add stderr handler: level = 'info' if self.env.debug: level = 'debug' else: if self.env.context == 'cli': if self.env.verbose > 0: level = 'info' else: level = 'warning' if log_mgr.handlers.has_key('console'): log_mgr.remove_handler('console') log_mgr.create_log_handlers([dict(name='console', stream=sys.stderr, level=level, format=LOGGING_FORMAT_STDERR)]) # Add file handler: if self.env.mode in ('dummy', 'unit_test'): return # But not if in unit-test mode if self.env.log is None: return log_dir = path.dirname(self.env.log) if not path.isdir(log_dir): try: os.makedirs(log_dir) except OSError: log.error('Could not create log_dir %r', log_dir) return level = 'info' if self.env.debug: level = 'debug' try: log_mgr.create_log_handlers([dict(name='file', filename=self.env.log, level=level, format=LOGGING_FORMAT_FILE)]) except IOError, e: log.error('Cannot open log file %r: %s', self.env.log, e) return