def test_wiki_page_refresh_by_title(self):
self.response.json = json_response(responses['wiki_page']['get'])
wiki_page = self.redmine.wiki_page.get('Foo', project_id=1)
self.assertEqual(wiki_page.title, 'Foo')
self.response.json = json_response({'wiki_page': {'title': 'Bar'}})
wiki_page = wiki_page.refresh()
self.assertEqual(wiki_page.title, 'Bar')
def test_wiki_page_includes(self):
response_includes = responses['wiki_page']['get']
self.response.json = json_response(response_includes)
wiki_page = self.redmine.wiki_page.get('Foo', project_id=1)
response_includes['wiki_page']['attachments'] = responses['attachment']['get']['attachment']
self.response.json = json_response(response_includes)
self.assertIsInstance(wiki_page.attachments, ResourceSet)
def test_saving_existing_resource_updates_it(self):
self.response.json = json_response(responses['project']['get'])
project = self.redmine.project.get(1)
project.name = 'Bar'
self.assertEqual(project.save(), True)
self.response.json = json_response({'project': {'id': 1, 'name': 'Bar'}})
project = project.refresh()
self.assertEqual(project.name, 'Bar')
def test_can_refresh_itself(self):
self.response.json = json_response(responses['project']['get'])
project = self.redmine.project.get(1)
self.assertEqual(project.id, 1)
self.assertEqual(project.name, 'Foo')
self.response.json = json_response({'project': {'id': 2, 'name': 'Bar'}})
project = project.refresh()
self.assertEqual(project.id, 2)
self.assertEqual(project.name, 'Bar')
def test_group_includes(self):
response_includes = responses['group']['get']
self.response.json = json_response(response_includes)
group = self.redmine.group.get(1)
response_includes['group']['memberships'] = responses['project_membership']['filter']['memberships']
self.response.json = json_response(response_includes)
self.assertIsInstance(group.memberships, ResourceSet)
response_includes['group']['users'] = responses['user']['all']['users']
self.response.json = json_response(response_includes)
self.assertIsInstance(group.users, ResourceSet)
def test_project_includes(self):
response_includes = responses['project']['get']
self.response.json = json_response(response_includes)
project = self.redmine.project.get(1)
response_includes['project'].update(responses['issue_category']['filter'])
self.response.json = json_response(response_includes)
self.assertIsInstance(project.issue_categories, ResourceSet)
response_includes['project'].update(responses['tracker']['all'])
self.response.json = json_response(response_includes)
self.assertIsInstance(project.trackers, ResourceSet)
def setUp(self):
self.url = URL
self.redmine = Redmine(self.url)
self.response = mock.Mock(status_code=200, json=json_response(response))
patcher = mock.patch('requests.get', return_value=self.response)
patcher.start()
self.addCleanup(patcher.stop)
def test_group_all(self):
self.response.json = json_response(responses['group']['all'])
groups = self.redmine.group.all()
self.assertEqual(groups[0].id, 1)
self.assertEqual(groups[0].name, 'Foo')
self.assertEqual(groups[1].id, 2)
self.assertEqual(groups[1].name, 'Bar')
def test_version_filter(self):
self.response.json = json_response(responses['version']['filter'])
versions = self.redmine.version.filter(project_id=1)
self.assertEqual(versions[0].id, 1)
self.assertEqual(versions[0].name, 'Foo')
self.assertEqual(versions[1].id, 2)
self.assertEqual(versions[1].name, 'Bar')
def test_project_all(self):
self.response.json = json_response(responses['project']['all'])
projects = self.redmine.project.all()
self.assertEqual(projects[0].id, 1)
self.assertEqual(projects[0].name, 'Foo')
self.assertEqual(projects[1].id, 2)
self.assertEqual(projects[1].name, 'Bar')
def test_validation_error_exception(self):
from redmine.exceptions import ValidationError
self.response.status_code = 422
self.response.json = json_response(
{'errors': ['foo', 'bar', ['foo', 'bar']]})
self.assertRaises(ValidationError,
lambda: self.redmine.request('post', self.url))
def test_role_all(self):
self.response.json = json_response(responses['role']['all'])
roles = self.redmine.role.all()
self.assertEqual(roles[0].id, 1)
self.assertEqual(roles[0].name, 'Foo')
self.assertEqual(roles[1].id, 2)
self.assertEqual(roles[1].name, 'Bar')
def test_issue_add_watcher_raises_exception_if_wrong_version(self):
from redmine.exceptions import ResourceVersionMismatchError
self.response.json = json_response(responses['issue']['get'])
self.redmine.ver = '2.2.0'
issue = self.redmine.issue.get(1)
self.response.content = ''
self.assertRaises(ResourceVersionMismatchError, lambda: issue.watcher.add(1))
def test_saving_new_resource_creates_it(self):
self.response.status_code = 201
self.response.json = json_response(responses['project']['get'])
project = self.redmine.project.new()
project.name = 'Foo'
self.assertEqual(project.save(), True)
self.assertEqual(project.id, 1)
def test_tracker_all(self):
self.response.json = json_response(responses['tracker']['all'])
trackers = self.redmine.tracker.all()
self.assertEqual(trackers[0].id, 1)
self.assertEqual(trackers[0].name, 'Foo')
self.assertEqual(trackers[1].id, 2)
self.assertEqual(trackers[1].name, 'Bar')
def test_query_all(self):
self.response.json = json_response(responses['query']['all'])
queries = self.redmine.query.all()
self.assertEqual(queries[0].id, 1)
self.assertEqual(queries[0].name, 'Foo')
self.assertEqual(queries[1].id, 2)
self.assertEqual(queries[1].name, 'Bar')
def test_news_filter(self):
self.response.json = json_response(responses['news']['filter'])
news = self.redmine.news.filter(project_id=1)
self.assertEqual(news[0].id, 1)
self.assertEqual(news[0].title, 'Foo')
self.assertEqual(news[1].id, 2)
self.assertEqual(news[1].title, 'Bar')
def test_issue_status_all(self):
self.response.json = json_response(responses['issue_status']['all'])
statuses = self.redmine.issue_status.all()
self.assertEqual(statuses[0].id, 1)
self.assertEqual(statuses[0].name, 'Foo')
self.assertEqual(statuses[1].id, 2)
self.assertEqual(statuses[1].name, 'Bar')
def test_news_all(self):
self.response.json = json_response(responses['news']['all'])
news = self.redmine.news.all()
self.assertEqual(news[0].id, 1)
self.assertEqual(news[0].title, 'Foo')
self.assertEqual(news[1].id, 2)
self.assertEqual(news[1].title, 'Bar')
def test_get_single_resource(self, mock_get):
mock_get.return_value = response = mock.Mock(status_code=200)
response.json = json_response({'project': {'name': 'Foo', 'identifier': 'foo', 'id': 1}})
project = self.redmine.project.get('foo')
self.assertEqual(project.name, 'Foo')
self.assertEqual(project.identifier, 'foo')
self.assertEqual(project.id, 1)
def test_successful_response_via_username_password(self):
self.redmine.username = '******'
self.redmine.password = '******'
self.response.status_code = 200
self.response.json = json_response({'success': True})
self.assertEqual(
self.redmine.request('get', self.url)['success'], True)
def test_issue_all(self):
self.response.json = json_response(responses['issue']['all'])
issues = self.redmine.issue.all()
self.assertEqual(issues[0].id, 1)
self.assertEqual(issues[0].subject, 'Foo')
self.assertEqual(issues[1].id, 2)
self.assertEqual(issues[1].subject, 'Bar')
def test_custom_field_all(self):
self.response.json = json_response(responses['custom_field']['all'])
fields = self.redmine.custom_field.all()
self.assertEqual(fields[0].id, 1)
self.assertEqual(fields[0].name, 'Foo')
self.assertEqual(fields[1].id, 2)
self.assertEqual(fields[1].name, 'Bar')
def test_issue_filter(self):
self.response.json = json_response(responses['issue']['filter'])
issues = self.redmine.issue.filter(project_id=1)
self.assertEqual(issues[0].id, 1)
self.assertEqual(issues[0].subject, 'Foo')
self.assertEqual(issues[1].id, 2)
self.assertEqual(issues[1].subject, 'Bar')
def test_dir_returns_resource_attributes(self):
self.response.json = json_response(responses['issue']['get'])
attributes = dir(self.redmine.issue.get(1))
self.assertIn('id', attributes)
self.assertIn('subject', attributes)
self.assertIn('relations', attributes)
self.assertIn('time_entries', attributes)
def test_issue_category_filter(self):
self.response.json = json_response(responses['issue_category']['filter'])
categories = self.redmine.issue_category.filter(project_id=1)
self.assertEqual(categories[0].id, 1)
self.assertEqual(categories[0].name, 'Foo')
self.assertEqual(categories[1].id, 2)
self.assertEqual(categories[1].name, 'Bar')
def test_issue_version_can_be_retrieved_via_version_attribute(self):
from redmine.resources import Version
self.response.json = json_response(
{'issue': {'subject': 'Foo', 'id': 1, 'fixed_version': {'id': 1, 'name': 'Foo'}}}
)
issue = self.redmine.issue.get(1)
self.assertIsInstance(issue.version, Version)
def test_user_all(self):
self.response.json = json_response(responses['user']['all'])
users = self.redmine.user.all()
self.assertEqual(users[0].id, 1)
self.assertEqual(users[0].firstname, 'John')
self.assertEqual(users[1].id, 2)
self.assertEqual(users[1].firstname, 'Jack')
def test_project_membership_update(self):
self.response.json = json_response(responses['project_membership']['get'])
membership = self.redmine.project_membership.get(1)
membership.role_ids = [1, 2]
self.assertEqual(membership.save(), True)
self.assertEqual(membership.roles[0].id, 1)
self.assertEqual(membership.roles[1].id, 2)
def test_user_filter(self):
self.response.json = json_response(responses['user']['filter'])
users = self.redmine.user.filter(status_id=2)
self.assertEqual(users[0].id, 1)
self.assertEqual(users[0].firstname, 'John')
self.assertEqual(users[1].id, 2)
self.assertEqual(users[1].firstname, 'Jack')
def test_enumeration_filter(self):
self.response.json = json_response(responses['enumeration']['filter'])
enumerations = self.redmine.enumeration.filter(resource='time_entry_activities')
self.assertEqual(enumerations[0].id, 1)
self.assertEqual(enumerations[0].name, 'Foo')
self.assertEqual(enumerations[1].id, 2)
self.assertEqual(enumerations[1].name, 'Bar')
def test_time_entry_filter(self):
self.response.json = json_response(responses['time_entry']['filter'])
time_entries = self.redmine.time_entry.filter(issue_id=1)
self.assertEqual(time_entries[0].id, 1)
self.assertEqual(time_entries[0].hours, 3)
self.assertEqual(time_entries[1].id, 2)
self.assertEqual(time_entries[1].hours, 4)
def test_time_entry_all(self):
self.response.json = json_response(responses['time_entry']['all'])
time_entries = self.redmine.time_entry.all()
self.assertEqual(time_entries[0].id, 1)
self.assertEqual(time_entries[0].hours, 3)
self.assertEqual(time_entries[1].id, 2)
self.assertEqual(time_entries[1].hours, 4)
def test_offset_limit(self):
response_with_limit_offset = {'total_count': 2, 'limit': 3, 'offset': 1, 'projects': response['projects'][1:3]}
self.response.json = json_response(response_with_limit_offset)
projects = self.redmine.project.all()[1:3]
self.assertEqual(projects.limit, 3)
self.assertEqual(projects.offset, 1)
self.assertEqual(projects[0].id, 2)
self.assertEqual(projects[1].id, 3)
def test_offset_limit_all(self):
self.response.json = json_response(dict(response, total_count=3, limit=0, offset=0))
projects = self.redmine.project.all()
self.assertEqual(projects.limit, 0)
self.assertEqual(projects.offset, 0)
self.assertEqual(projects[0].id, 1)
self.assertEqual(projects[1].id, 2)
self.assertEqual(projects[2].id, 3)
def test_sliced_resultset_is_empty(self):
self.response.json = json_response({
'limit': 100,
'projects': [],
'total_count': 0,
'offset': 0
})
projects = self.redmine.project.all()[:200]
self.assertEqual(len(projects), 0)
self.assertEqual(list(projects), [])
def test_auth(self):
self.redmine.username = '******'
self.redmine.password = '******'
self.response.status_code = 200
self.response.json = json_response(
{'user': {
'firstname': 'John',
'lastname': 'Smith',
'id': 1
}})
self.assertEqual(self.redmine.auth().firstname, 'John')
def test_update_resource_with_uploads(self, mock_post, mock_put):
mock_put.return_value = mock.Mock(status_code=200, content='')
mock_post.return_value = response = mock.Mock(status_code=201)
response.json = json_response({'upload': {'token': '123456'}})
manager = self.redmine.issue
manager.params['subject'] = 'Foo'
self.assertEqual(
manager.update(1, subject='Bar', uploads=[{
'path': 'foo'
}]), True)
del manager.params['subject']
def test_create_resource(self, mock_post):
mock_post.return_value = response = mock.Mock(status_code=201)
response.json = json_response(
{'user': {
'firstname': 'John',
'lastname': 'Smith',
'id': 1
}})
user = self.redmine.user.create(firstname='John', lastname='Smith')
self.assertEqual(user.firstname, 'John')
self.assertEqual(user.lastname, 'Smith')
def test_total_count_mimic(self):
response_with_custom_fields = {
'project':
dict(response['projects'][0],
custom_fields=[{
'id': 1,
'value': 0
}])
}
self.response.json = json_response(response_with_custom_fields)
project = self.redmine.project.get('foo')
self.assertEqual(project.custom_fields.total_count, 1)
def test_get_single_resource(self, mock_get):
mock_get.return_value = response = mock.Mock(status_code=200)
response.json = json_response(
{'project': {
'name': 'Foo',
'identifier': 'foo',
'id': 1
}})
project = self.redmine.project.get('foo')
self.assertEqual(project.name, 'Foo')
self.assertEqual(project.identifier, 'foo')
self.assertEqual(project.id, 1)
def test_create_resource_with_uploads(self, mock_post):
mock_post.return_value = response = mock.Mock(status_code=201)
response.json = json_response({
'upload': {
'token': '123456'
},
'issue': {
'subject': 'Foo',
'project_id': 1,
'id': 1
}
})
issue = self.redmine.issue.create(project_id=1,
subject='Foo',
uploads=[{
'path': 'foo'
}])
self.assertEqual(issue.project_id, 1)
self.assertEqual(issue.subject, 'Foo')
def test_successful_file_upload(self):
self.response.status_code = 201
self.response.json = json_response({'upload': {'token': '123456'}})
self.assertEqual(self.redmine.upload('foo'), '123456')
def test_successful_response_via_api_key(self):
self.redmine.key = '123'
self.response.status_code = 200
self.response.json = json_response({'success': True})
self.assertEqual(
self.redmine.request('get', self.url)['success'], True)
def test_total_count(self):
self.response.json = json_response(dict(response, total_count=3, limit=0, offset=0))
projects = self.redmine.project.all()
len(projects)
self.assertEqual(projects.total_count, 3)
