def setUp(self):
jira_backend = 'waldur_mastermind.support.backend.atlassian:ServiceDeskBackend'
settings.WALDUR_SUPPORT['ENABLED'] = True
settings.WALDUR_SUPPORT['ACTIVE_BACKEND'] = jira_backend
settings.task_always_eager = True
self.issue = factories.IssueFactory()
backend_issue_raw = json.loads(load_resource('jira_issue_raw.json'))
self.backend_issue = jira.resources.Issue({'server': 'example.com'}, None, backend_issue_raw)
self.backend = ServiceDeskBackend()
self.impact_field_id = 'customfield_10116'
path = mock.patch.object(ServiceDeskBackend, 'get_backend_issue',
new=mock.Mock(return_value=self.backend_issue))
path.start()
self.first_response_sla = timezone.now()
path = mock.patch.object(ServiceDeskBackend, '_get_first_sla_field',
new=mock.Mock(return_value=self.first_response_sla))
path.start()
def side_effect(arg):
if arg == 'Impact':
return self.impact_field_id
path = mock.patch.object(ServiceDeskBackend, 'get_field_id_by_name',
new=mock.Mock(side_effect=side_effect))
path.start()
def setUp(self):
jira_backend = 'waldur_mastermind.support.backend.atlassian:ServiceDeskBackend'
settings.WALDUR_SUPPORT['ENABLED'] = True
settings.WALDUR_SUPPORT['ACTIVE_BACKEND'] = jira_backend
self.comment = factories.CommentFactory()
backend_comment_raw = json.loads(
load_resource('jira_comment_raw.json'))
self.backend_comment = jira.resources.Comment(
{'server': 'example.com'}, None, backend_comment_raw)
self.backend = ServiceDeskBackend()
self.internal = {'value': {'internal': False}}
path = mock.patch.object(
ServiceDeskBackend,
'_get_property',
new=mock.Mock(return_value=self.internal),
)
path.start()
path = mock.patch.object(
ServiceDeskBackend,
'get_backend_comment',
new=mock.Mock(return_value=self.backend_comment),
)
path.start()
def setUp(self):
jira_backend = 'waldur_mastermind.support.backend.atlassian:ServiceDeskBackend'
settings.WALDUR_SUPPORT['ENABLED'] = True
settings.WALDUR_SUPPORT['ACTIVE_BACKEND'] = jira_backend
self.issue = factories.IssueFactory()
backend_issue_raw = json.loads(load_resource('jira_issue_raw.json'))
self.backend_issue = jira.resources.Issue({'server': 'example.com'}, None, backend_issue_raw)
backend_attachment_raw = json.loads(load_resource('jira_attachment_raw.json'))
self.backend_attachment = jira.resources.Attachment({'server': 'example.com'}, None, backend_attachment_raw)
self.backend_issue.fields.attachment.append(self.backend_attachment)
self.backend = ServiceDeskBackend()
path = mock.patch.object(ServiceDeskBackend, 'get_backend_issue',
new=mock.Mock(return_value=self.backend_issue))
path.start()
path = mock.patch.object(ServiceDeskBackend, 'get_backend_attachment',
new=mock.Mock(return_value=self.backend_attachment))
path.start()
GIF = 'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'
file_content = six.BytesIO(GIF.decode('base64'))
path = mock.patch.object(AttachmentSynchronizer, '_download_file',
new=mock.Mock(return_value=file_content))
path.start()
def test_comment_has_been_created_if_feedback_has_been_synchronized(self):
with mock.patch.object(ServiceDeskBackend, 'create_comment'):
backend = ServiceDeskBackend()
feedback = factories.FeedbackFactory(comment='Test Feedback', evaluation=0)
backend.create_feedback(feedback)
self.assertTrue(
models.Feedback.objects.filter(issue=feedback.issue).exists()
)
def test_pull_request_types(self):
self._mock_jira()
self.mock_jira().request_types.return_value = [
RequestType(
{'server': ''},
None,
raw={
'name': 'Help',
'id': '1',
'issueTypeId': '10101'
},
)
]
self.mock_jira().issue_type.return_value = IssueType(
{'server': ''}, None, raw={
'name': 'Service Request',
'id': '1'
})
issue_type = settings.WALDUR_SUPPORT['ISSUE']['types'][0]
factories.RequestTypeFactory(issue_type_name=issue_type)
issue = factories.IssueFactory(reporter=None,
backend_id=None,
type=issue_type)
factories.SupportCustomerFactory(user=issue.caller)
ServiceDeskBackend().create_issue(issue)
self.assertEqual(models.RequestType.objects.count(), 1)
def setUp(self):
super(BaseBackendTest, self).setUp()
self.fixture = fixtures.SupportFixture()
self.backend = ServiceDeskBackend()
jira_patcher = mock.patch('waldur_jira.backend.JIRA')
self.mocked_jira = jira_patcher.start()()
self.mocked_jira.fields.return_value = [
{
'clauseNames': 'Caller',
'id': 'field101',
},
{
'clauseNames': 'Original Reporter',
'id': 'field102',
},
{
'clauseNames': 'Time to first response',
'id': 'field103',
},
{
'clauseNames': 'Impact',
'id': 'field104',
},
]
def test_if_issue_does_not_have_reporter_organisation_field_not_fill(self):
self._mock_jira()
issue = factories.IssueFactory(reporter=None, backend_id=None)
factories.SupportCustomerFactory(user=issue.caller)
factories.RequestTypeFactory(issue_type_name=issue.type)
ServiceDeskBackend().create_issue(issue)
kwargs = self.mock_jira().create_customer_request.return_value.update.call_args[1]
self.assertTrue('field105' not in kwargs.keys())
def test_not_create_user_if_user_exists_but_he_inactive(self, mocked_jira):
def side_effect(*args, **kwargs):
if kwargs.get('includeInactive'):
return [jira.User(None, None, raw={'active': False})]
return []
mocked_jira().search_users.side_effect = side_effect
user = structure_factories.UserFactory()
self.assertRaises(exceptions.SupportUserInactive,
ServiceDeskBackend().create_user, user)
def setUp(self):
self.issue = factories.IssueFactory()
backend_issue_raw = json.loads(load_resource('jira_issue_raw.json'))
self.backend_issue = jira.resources.Issue({'server': 'example.com'},
None, backend_issue_raw)
self.impact_field_id = 'customfield_10116'
self.first_response_sla = timezone.now()
def side_effect(arg):
if arg == 'Impact':
return self.impact_field_id
self.backend = ServiceDeskBackend()
self.backend.get_backend_issue = mock.Mock(
return_value=self.backend_issue)
self.backend._get_first_sla_field = mock.Mock(
return_value=self.first_response_sla)
self.backend.get_field_id_by_name = mock.Mock(side_effect=side_effect)
def setUp(self):
super(BaseBackendTest, self).setUp()
self.fixture = fixtures.SupportFixture()
self.backend = ServiceDeskBackend()
jira_patcher = mock.patch('waldur_jira.backend.JIRA')
self.mocked_jira = jira_patcher.start()()
self.mocked_jira.fields.return_value = json.loads(load_resource('jira_fields.json'))
mock_backend_users = [User({'server': ''}, None, raw={'key': 'user_1', 'active': True})]
self.mocked_jira.search_users.return_value = mock_backend_users
class TestUpdateAttachmentFromJira(APITransactionTestCase):
def setUp(self):
jira_backend = 'waldur_mastermind.support.backend.atlassian:ServiceDeskBackend'
settings.WALDUR_SUPPORT['ENABLED'] = True
settings.WALDUR_SUPPORT['ACTIVE_BACKEND'] = jira_backend
self.issue = factories.IssueFactory()
backend_issue_raw = json.loads(load_resource('jira_issue_raw.json'))
self.backend_issue = jira.resources.Issue({'server': 'example.com'},
None, backend_issue_raw)
backend_attachment_raw = json.loads(
load_resource('jira_attachment_raw.json'))
self.backend_attachment = jira.resources.Attachment(
{'server': 'example.com'}, None, backend_attachment_raw)
self.backend_issue.fields.attachment.append(self.backend_attachment)
self.backend = ServiceDeskBackend()
path = mock.patch.object(
ServiceDeskBackend,
'get_backend_issue',
new=mock.Mock(return_value=self.backend_issue),
)
path.start()
path = mock.patch.object(
ServiceDeskBackend,
'get_backend_attachment',
new=mock.Mock(return_value=self.backend_attachment),
)
path.start()
file_content = BytesIO(
base64.b64decode(
'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'))
path = mock.patch.object(
AttachmentSynchronizer,
'_download_file',
new=mock.Mock(return_value=file_content),
)
path.start()
def tearDown(self):
mock.patch.stopall()
def test_add_attachment(self):
self.backend.update_attachment_from_jira(self.issue)
self.assertEqual(self.issue.attachments.count(), 1)
def test_delete_attachment(self):
self.backend.update_attachment_from_jira(self.issue)
self.assertEqual(self.issue.attachments.count(), 1)
self.backend_issue.fields.attachment = []
self.backend.update_attachment_from_jira(self.issue)
self.assertEqual(self.issue.attachments.count(), 0)
class TestUpdateCommentFromJira(APITransactionTestCase):
def setUp(self):
jira_backend = 'waldur_mastermind.support.backend.atlassian:ServiceDeskBackend'
settings.WALDUR_SUPPORT['ENABLED'] = True
settings.WALDUR_SUPPORT['ACTIVE_BACKEND'] = jira_backend
self.comment = factories.CommentFactory()
backend_comment_raw = json.loads(
load_resource('jira_comment_raw.json'))
self.backend_comment = jira.resources.Comment(
{'server': 'example.com'}, None, backend_comment_raw)
self.backend = ServiceDeskBackend()
self.internal = {'value': {'internal': False}}
path = mock.patch.object(
ServiceDeskBackend,
'_get_property',
new=mock.Mock(return_value=self.internal),
)
path.start()
path = mock.patch.object(
ServiceDeskBackend,
'get_backend_comment',
new=mock.Mock(return_value=self.backend_comment),
)
path.start()
def tearDown(self):
mock.patch.stopall()
def test_update_comment_description(self):
self.backend.update_comment_from_jira(self.comment)
self.comment.refresh_from_db()
self.assertEqual(
self.comment.description,
self.comment.clean_message(self.backend_comment.body),
)
def test_update_comment_is_public(self):
self.internal['value']['internal'] = True
self.backend.update_comment_from_jira(self.comment)
self.internal['value']['internal'] = False
self.comment.refresh_from_db()
self.assertEqual(self.comment.is_public, False)
def test_webhook_cleans_up_user_info_and_does_not_update_comment_if_it_is_not_changed(
self, ):
expected_comment_body = self.comment.description
jira_comment_body = '[Luke Skywalker 19BBY-TA-T16]: %s' % expected_comment_body
self.backend_comment.body = jira_comment_body
self.backend.update_comment_from_jira(self.comment)
self.comment.refresh_from_db()
self.assertEqual(self.comment.description, expected_comment_body)
def get_backend(self):
return ServiceDeskBackend()
class TestUpdateIssueFromJira(APITransactionTestCase):
def setUp(self):
self.issue = factories.IssueFactory()
backend_issue_raw = json.loads(load_resource('jira_issue_raw.json'))
self.backend_issue = jira.resources.Issue({'server': 'example.com'},
None, backend_issue_raw)
self.impact_field_id = 'customfield_10116'
self.request_feedback = 'customfield_10216'
self.first_response_sla = timezone.now()
def side_effect(arg):
if arg == 'Impact':
return self.impact_field_id
elif arg == 'Request feedback':
return self.request_feedback
self.backend = ServiceDeskBackend()
self.backend.get_backend_issue = mock.Mock(
return_value=self.backend_issue)
self.backend._get_first_sla_field = mock.Mock(
return_value=self.first_response_sla)
self.backend.get_field_id_by_name = mock.Mock(side_effect=side_effect)
def update_issue_from_jira(self):
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
def test_update_issue_impact_field(self):
impact_field_value = 'Custom Value'
setattr(self.backend_issue.fields, self.impact_field_id,
impact_field_value)
self.update_issue_from_jira()
self.assertEqual(self.issue.impact, impact_field_value)
def test_update_issue_assignee(self):
assignee = factories.SupportUserFactory(
backend_id='support_user_backend_id')
backend_assignee_user = MockSupportUser(key=assignee.backend_id)
self.backend_issue.fields.assignee = backend_assignee_user
self.update_issue_from_jira()
self.assertEqual(self.issue.assignee.id, assignee.id)
def test_update_issue_reporter(self):
reporter = factories.SupportUserFactory(
backend_id='support_user_backend_id')
backend_reporter_user = MockSupportUser(key=reporter.backend_id)
self.backend_issue.fields.reporter = backend_reporter_user
self.update_issue_from_jira()
self.assertEqual(self.issue.reporter.id, reporter.id)
def test_update_issue_summary(self):
expected_summary = 'Happy New Year'
self.backend_issue.fields.summary = expected_summary
self.update_issue_from_jira()
self.assertEqual(self.issue.summary, expected_summary)
def test_update_issue_link(self):
permalink = self.backend_issue.permalink()
self.update_issue_from_jira()
self.assertEqual(self.issue.link, permalink)
def test_update_first_response_sla(self):
self.update_issue_from_jira()
self.assertEqual(self.issue.first_response_sla,
self.first_response_sla)
def test_update_issue_resolution(self):
expected_resolution = MockResolution(name='Done')
self.backend_issue.fields.resolution = expected_resolution
self.update_issue_from_jira()
self.assertEqual(self.issue.resolution, expected_resolution.name)
def test_resolution_is_empty_if_it_is_none(self):
expected_resolution = None
self.backend_issue.fields.resolution = expected_resolution
self.update_issue_from_jira()
self.assertEqual(self.issue.resolution, '')
def test_update_issue_status(self):
self.update_issue_from_jira()
self.assertEqual(self.issue.status,
self.backend_issue.fields.status.name)
def test_web_hook_does_not_trigger_issue_update_email_if_the_issue_was_not_updated(
self, ):
self.update_issue_from_jira()
self.update_issue_from_jira()
self.assertEqual(len(mail.outbox), 0)
def test_web_hook_does_trigger_issue_update_email_if_the_issue_was_updated(
self):
self.update_issue_from_jira()
self.backend_issue.fields.summary = 'New summary'
self.update_issue_from_jira()
self.assertEqual(len(mail.outbox), 1)
def test_issue_update_callback_creates_deletes_two_comments(self):
factories.CommentFactory(issue=self.issue)
factories.CommentFactory(issue=self.issue)
synchronizer = CommentSynchronizer(self.backend, self.issue,
self.backend_issue)
synchronizer.perform_update()
self.assertEqual(self.issue.comments.count(), 0)
def test_update_issue_feedback_request_field(self):
self.update_issue_from_jira()
self.assertEqual(self.issue.feedback_request, True)
setattr(self.backend_issue.fields, self.request_feedback, None)
self.update_issue_from_jira()
self.issue.refresh_from_db()
self.assertEqual(self.issue.feedback_request, False)
class TestUpdateIssueFromJira(APITransactionTestCase):
def setUp(self):
jira_backend = 'waldur_mastermind.support.backend.atlassian:ServiceDeskBackend'
settings.WALDUR_SUPPORT['ENABLED'] = True
settings.WALDUR_SUPPORT['ACTIVE_BACKEND'] = jira_backend
settings.task_always_eager = True
self.issue = factories.IssueFactory()
backend_issue_raw = json.loads(load_resource('jira_issue_raw.json'))
self.backend_issue = jira.resources.Issue({'server': 'example.com'}, None, backend_issue_raw)
self.backend = ServiceDeskBackend()
self.impact_field_id = 'customfield_10116'
path = mock.patch.object(ServiceDeskBackend, 'get_backend_issue',
new=mock.Mock(return_value=self.backend_issue))
path.start()
self.first_response_sla = timezone.now()
path = mock.patch.object(ServiceDeskBackend, '_get_first_sla_field',
new=mock.Mock(return_value=self.first_response_sla))
path.start()
def side_effect(arg):
if arg == 'Impact':
return self.impact_field_id
path = mock.patch.object(ServiceDeskBackend, 'get_field_id_by_name',
new=mock.Mock(side_effect=side_effect))
path.start()
def tearDown(self):
mock.patch.stopall()
settings.task_always_eager = False
def test_update_issue_impact_field(self):
impact_field_value = 'Custom Value'
setattr(self.backend_issue.fields, self.impact_field_id, impact_field_value)
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.impact, impact_field_value)
def test_update_issue_assignee(self):
assignee = factories.SupportUserFactory(backend_id='support_user_backend_id')
backend_assignee_user = MockSupportUser(key=assignee.backend_id)
self.backend_issue.fields.assignee = backend_assignee_user
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.assignee.id, assignee.id)
def test_update_issue_reporter(self):
reporter = factories.SupportUserFactory(backend_id='support_user_backend_id')
backend_reporter_user = MockSupportUser(key=reporter.backend_id)
self.backend_issue.fields.reporter = backend_reporter_user
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.reporter.id, reporter.id)
def test_update_issue_summary(self):
expected_summary = 'Happy New Year'
self.backend_issue.fields.summary = expected_summary
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.summary, expected_summary)
def test_update_issue_link(self):
permalink = self.backend_issue.permalink()
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.link, permalink)
def test_update_first_response_sla(self):
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.first_response_sla, self.first_response_sla)
def test_update_issue_resolution(self):
expected_resolution = 'Done'
self.backend_issue.fields.resolution = expected_resolution
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.resolution, expected_resolution)
def test_resolution_is_empty_if_it_is_none(self):
expected_resolution = None
self.backend_issue.fields.resolution = expected_resolution
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.resolution, '')
def test_update_issue_status(self):
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.assertEqual(self.issue.status, self.backend_issue.fields.status.name)
def test_web_hook_does_not_trigger_issue_update_email_if_the_issue_was_not_updated(self):
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
self.backend.update_issue_from_jira(self.issue)
self.assertEqual(len(mail.outbox), 0)
def test_web_hook_does_trigger_issue_update_email_if_the_issue_was_updated(self):
self.backend.update_issue_from_jira(self.issue)
self.issue.refresh_from_db()
expected_resolution = 'Done'
self.backend_issue.fields.resolution = expected_resolution
self.backend.update_issue_from_jira(self.issue)
self.assertEqual(len(mail.outbox), 1)
def test_issue_update_callback_creates_deletes_two_comments(self):
factories.CommentFactory(issue=self.issue)
factories.CommentFactory(issue=self.issue)
synchronizer = CommentSynchronizer(self.backend, self.issue, self.backend_issue)
synchronizer.perform_update()
self.assertEqual(self.issue.comments.count(), 0)
