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 __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_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
