def test_send_success_message(self):
callback = JiraRegistry.get('write_success_comment')
issue = Issue({}, None)
issue.id = 'JIRA-42'
callback(self.jira_plugin, issue, self, "a message")
self.jira_plugin.jira_client.add_comment.assert_called_once_with(issue, mock.ANY)
self.assertEqual(0, len(self.jira_plugin.regressions))
def rehydrate_issue(self, filename):
stored = json.loads(self.get_asset_contents(filename))
return Issue(
stored["options"],
None,
stored["raw"],
)
def test_warn_regression(self):
callback = JiraRegistry.get('warn_regression')
issue = Issue({}, None)
issue.id = 'JIRA-42'
callback(self.jira_plugin, issue, self, "a message")
self.jira_plugin.jira_client.add_comment.assert_called_once_with(issue, mock.ANY)
self.assertEqual(1, len(self.jira_plugin.regressions))
self.assertEqual(self.jira_plugin.regressions[0].issue_id, issue.id)
def create_customer_request(self,
fields=None,
prefetch=True,
use_old_api=False,
**fieldargs):
"""The code for this function is almost completely copied from
function create_customer_request of the JIRA library"""
data = fields
p = data['serviceDeskId']
service_desk = None
if isinstance(p, str) or isinstance(p, int):
service_desk = self.service_desk(p)
elif isinstance(p, ServiceDesk):
service_desk = p
data['serviceDeskId'] = service_desk.id
p = data['requestTypeId']
if isinstance(p, int):
data['requestTypeId'] = p
elif isinstance(p, str):
data['requestTypeId'] = self.request_type_by_name(service_desk, p).id
requestParticipants = data.pop('requestParticipants', None)
url = self._options['server'] + '/rest/servicedeskapi/request'
headers = {'X-ExperimentalApi': 'opt-in'}
r = self._session.post(url, headers=headers, data=json.dumps(data))
raw_issue_json = json_loads(r)
if 'issueKey' not in raw_issue_json:
raise JIRAError(r.status_code, request=r)
if requestParticipants:
url = (self._options['server'] +
'/rest/servicedeskapi/request/%s/participant' %
raw_issue_json['issueKey'])
headers = {'X-ExperimentalApi': 'opt-in'}
if use_old_api:
data = {'usernames': requestParticipants}
else:
data = {'accountIds': requestParticipants}
r = self._session.post(url, headers=headers, json=data)
if r.status_code != status.HTTP_200_OK:
raise JIRAError(r.status_code, request=r)
if prefetch:
return self.issue(raw_issue_json['issueKey'])
else:
return Issue(self._options, self._session, raw=raw_issue_json)
def sprint_issues(cls, board_id, sprint_id):
r_json = cls._get_json(
'rapid/charts/sprintreport?rapidViewId=%s&sprintId=%s' %
(board_id, sprint_id),
base=cls.AGILE_BASE_URL)
issues = []
for t in type_of_issues_to_pull:
if t in r_json['contents']:
issues += [
Issue(cls._options, cls._session, raw_issues_json)
for raw_issues_json in r_json['contents'][t]
]
return {x.key: x for x in issues}.values()
def test_apply_jira_transition(self):
register_transition('write_failure_and_back_in_dev', 'Set as To Do', 'test={test} message={message}')
callback = JiraRegistry.get('write_failure_and_back_in_dev')
issue = Issue({}, None)
issue.id = 'JIRA-42'
callback(self.jira_plugin, issue, self, "a message")
self.jira_plugin.jira_client.add_comment.assert_called_once_with(issue,
'test={test} message={message}'.format(
message='a message',
test=self
))
self.jira_plugin.jira_client.find_transitionid_by_name\
.assert_called_once_with(issue, 'Set as To Do')
self.jira_plugin.jira_client.transition_issue\
.assert_called_once_with(issue, 1)
self.assertEqual(0, len(self.jira_plugin.regressions))
def cached_issue(self):
if not hasattr(self, '_cached_issue'):
try:
issue_path = self.get_metadata_path('issue.json')
with io.open(issue_path, 'r', encoding='utf-8') as _in:
storable = json.loads(_in.read())
self._cached_issue = Issue(
storable['options'],
None,
storable['raw'],
)
except IOError:
self.log(
'Error encountered while loading cached issue!',
level=logging.ERROR,
)
self._cached_issue = self.issue
return self._cached_issue
def cached_issue(self):
if not hasattr(self, "_cached_issue"):
try:
issue_path = self.get_metadata_path("issue.json")
with io.open(issue_path, "r", encoding="utf-8") as _in:
storable = json.loads(_in.read())
self._cached_issue = Issue(
storable["options"],
None,
storable["raw"],
)
except IOError:
self.log(
"Error encountered while loading cached issue!",
level=logging.ERROR,
)
self._cached_issue = self.issue
return self._cached_issue
def rehydrate(self, value: Dict) -> Issue:
return Issue({}, None, value)
