def test_update_wiki_updates_contributor_comments_viewed_timestamp(self):
contributor = AuthUserFactory()
project = ProjectFactory(creator=self.user, is_public=True)
project.add_contributor(contributor)
project.save()
wiki_page = WikiFactory(node=project, page_name='test')
wiki = WikiVersionFactory(wiki_page=wiki_page)
comment = CommentFactory(node=project, target=Guid.load(wiki_page._id), user=self.user)
# user views comments -- sets user.comments_viewed_timestamp
url = project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki_page._id
}, auth=self.user.auth)
assert res.status_code == 200
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
# contributor views comments -- sets contributor.comments_viewed_timestamp
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki_page._id
}, auth=contributor.auth)
contributor.reload()
assert wiki_page._id in contributor.comments_viewed_timestamp
# user updates the wiki
wiki_page.update(self.user, 'Updating wiki')
comment.reload()
contributor.reload()
new_version_id = WikiVersion.objects.get_for_node(project, 'test')._id
assert wiki_page._id in contributor.comments_viewed_timestamp
assert comment.target.referent._id == wiki_page._id
def test_current_version_number_with_non_contiguous_version_numbers(self):
wiki = WikiFactory()
for i in range(1, 9):
WikiVersion(wiki_page=wiki, identifier=i, content=fake.sentence()).save()
for i in range(2, 6):
WikiVersion(wiki_page=wiki, identifier=i, content=fake.sentence()).save()
assert wiki.current_version_number == 5
latest_version = wiki.versions.order_by('-created')[0]
assert latest_version.is_current
assert wiki.get_version(5) == latest_version
def _set_up_public_project_with_wiki_page(self, project_options=None):
project_options = project_options or {}
self.public_project = ProjectFactory(is_public=True, creator=self.user, **project_options)
from addons.wiki.tests.factories import WikiFactory, WikiVersionFactory
with mock.patch('osf.models.AbstractNode.update_search'):
self.public_wiki_page = WikiFactory(node=self.public_project, user=self.user)
self.public_wiki = WikiVersionFactory(wiki_page=self.public_wiki_page, user=self.user)
self.public_url = '/{}wikis/{}/'.format(API_BASE, self.public_wiki_page._id)
return self.public_wiki_page
def test_update_wiki_updates_comments_and_user_comments_viewed_timestamp(self):
project = ProjectFactory(creator=self.user, is_public=True)
wiki_page = WikiFactory(node=project, page_name='test')
wiki = WikiVersionFactory(wiki_page=wiki_page)
comment = CommentFactory(node=project, target=Guid.load(wiki_page._id), user=UserFactory())
# user views comments -- sets user.comments_viewed_timestamp
url = project.api_url_for('update_comments_timestamp')
res = self.app.put_json(url, {
'page': 'wiki',
'rootId': wiki_page._id
}, auth=self.user.auth)
assert res.status_code == 200
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
# user updates the wiki
wiki_page.update(self.user, 'Updating wiki')
comment.reload()
self.user.reload()
assert wiki_page._id in self.user.comments_viewed_timestamp
assert comment.target.referent._id == wiki_page._id
class TestWikiDetailView(ApiWikiTestCase):
def _set_up_public_project_with_wiki_page(self, project_options=None):
project_options = project_options or {}
self.public_project = ProjectFactory(is_public=True, creator=self.user, **project_options)
from addons.wiki.tests.factories import WikiFactory, WikiVersionFactory
with mock.patch('osf.models.AbstractNode.update_search'):
self.public_wiki_page = WikiFactory(node=self.public_project, user=self.user)
self.public_wiki = WikiVersionFactory(wiki_page=self.public_wiki_page, user=self.user)
self.public_url = '/{}wikis/{}/'.format(API_BASE, self.public_wiki_page._id)
return self.public_wiki_page
def _set_up_private_project_with_wiki_page(self):
self.private_project = ProjectFactory(creator=self.user)
self.private_wiki = self._add_project_wiki_page(
self.private_project, self.user)
self.private_url = '/{}wikis/{}/'.format(
API_BASE, self.private_wiki._id)
def _set_up_public_registration_with_wiki_page(self):
self._set_up_public_project_with_wiki_page()
self.public_registration = RegistrationFactory(
project=self.public_project, user=self.user, is_public=True)
self.public_registration_wiki_id = WikiPage.objects.get_for_node(self.public_registration, 'home')._id
self.public_registration.save()
self.public_registration_url = '/{}wikis/{}/'.format(
API_BASE, self.public_registration_wiki_id)
def _set_up_private_registration_with_wiki_page(self):
self._set_up_private_project_with_wiki_page()
self.private_registration = RegistrationFactory(
project=self.private_project, user=self.user)
self.private_registration_wiki_id = WikiPage.objects.get_for_node(self.private_registration, 'home')._id
self.private_registration.save()
self.private_registration_url = '/{}wikis/{}/'.format(
API_BASE, self.private_registration_wiki_id)
def test_public_node_logged_out_user_can_view_wiki(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.public_wiki_page._id)
def test_public_node_logged_in_non_contributor_can_view_wiki(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.public_wiki_page._id)
def test_public_node_logged_in_contributor_can_view_wiki(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.public_wiki_page._id)
def test_private_node_logged_out_user_cannot_view_wiki(self):
self._set_up_private_project_with_wiki_page()
res = self.app.get(self.private_url, expect_errors=True)
assert_equal(res.status_code, 401)
assert_equal(res.json['errors'][0]['detail'],
'Authentication credentials were not provided.')
def test_private_node_logged_in_non_contributor_cannot_view_wiki(self):
self._set_up_private_project_with_wiki_page()
res = self.app.get(
self.private_url,
auth=self.non_contributor.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(
res.json['errors'][0]['detail'],
'You do not have permission to perform this action.')
def test_private_node_logged_in_contributor_can_view_wiki(self):
self._set_up_private_project_with_wiki_page()
res = self.app.get(self.private_url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.private_wiki._id)
def test_private_node_user_with_anonymous_link_can_view_wiki(self):
self._set_up_private_project_with_wiki_page()
private_link = PrivateLinkFactory(anonymous=True)
private_link.nodes.add(self.private_project)
private_link.save()
url = furl.furl(
self.private_url).add(
query_params={
'view_only': private_link.key}).url
res = self.app.get(url)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.private_wiki._id)
def test_private_node_user_with_view_only_link_can_view_wiki(self):
self._set_up_private_project_with_wiki_page()
private_link = PrivateLinkFactory(anonymous=False)
private_link.nodes.add(self.private_project)
private_link.save()
url = furl.furl(
self.private_url).add(
query_params={
'view_only': private_link.key}).url
res = self.app.get(url)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.private_wiki._id)
def test_public_registration_logged_out_user_cannot_view_wiki(self):
self._set_up_public_registration_with_wiki_page()
res = self.app.get(self.public_registration_url, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.public_registration_wiki_id)
def test_public_registration_logged_in_non_contributor_cannot_view_wiki(
self):
self._set_up_public_registration_with_wiki_page()
res = self.app.get(
self.public_registration_url,
auth=self.non_contributor.auth,
expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.public_registration_wiki_id)
def test_public_registration_contributor_can_view_wiki(self):
self._set_up_public_registration_with_wiki_page()
res = self.app.get(self.public_registration_url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.public_registration_wiki_id)
def test_user_cannot_view_withdrawn_registration_wikis(self):
self._set_up_public_registration_with_wiki_page()
# TODO: Remove mocking when StoredFileNode is implemented
with mock.patch('osf.models.AbstractNode.update_search'):
withdrawal = self.public_registration.retract_registration(
user=self.user, save=True)
token = withdrawal.approval_state.values()[0]['approval_token']
withdrawal.approve_retraction(self.user, token)
withdrawal.save()
res = self.app.get(
self.public_registration_url,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(
res.json['errors'][0]['detail'],
'You do not have permission to perform this action.')
def test_private_registration_logged_out_user_cannot_view_wiki(self):
self._set_up_private_registration_with_wiki_page()
res = self.app.get(self.private_registration_url, expect_errors=True)
assert_equal(res.status_code, 401)
assert_equal(res.json['errors'][0]['detail'],
'Authentication credentials were not provided.')
def test_private_registration_logged_in_non_contributor_cannot_view_wiki(
self):
self._set_up_private_registration_with_wiki_page()
res = self.app.get(
self.private_registration_url,
auth=self.non_contributor.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(
res.json['errors'][0]['detail'],
'You do not have permission to perform this action.')
def test_private_registration_contributor_can_view_wiki(self):
self._set_up_private_registration_with_wiki_page()
res = self.app.get(self.private_registration_url, auth=self.user.auth)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['id'], self.private_registration_wiki_id)
def test_wiki_has_user_link(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url)
url = res.json['data']['relationships']['user']['links']['related']['href']
expected_url = '/{}users/{}/'.format(API_BASE, self.user._id)
assert_equal(res.status_code, 200)
assert_equal(urlparse(url).path, expected_url)
def test_wiki_has_node_link(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url)
url = res.json['data']['relationships']['node']['links']['related']['href']
expected_url = '/{}nodes/{}/'.format(API_BASE, self.public_project._id)
assert_equal(res.status_code, 200)
assert_equal(urlparse(url).path, expected_url)
def test_wiki_has_comments_link(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url)
assert_equal(res.status_code, 200)
url = res.json['data']['relationships']['comments']['links']['related']['href']
comment = CommentFactory(
node=self.public_project,
target=Guid.load(
self.public_wiki_page._id),
user=self.user)
res = self.app.get(url)
assert_equal(res.status_code, 200)
assert_equal(res.json['data'][0]['type'], 'comments')
def test_only_project_contrib_can_comment_on_closed_project(self):
self._set_up_public_project_with_wiki_page(
project_options={'comment_level': 'private'})
res = self.app.get(self.public_url, auth=self.user.auth)
can_comment = res.json['data']['attributes']['current_user_can_comment']
assert_equal(res.status_code, 200)
assert_equal(can_comment, True)
res = self.app.get(self.public_url, auth=self.non_contributor.auth)
can_comment = res.json['data']['attributes']['current_user_can_comment']
assert_equal(res.status_code, 200)
assert_equal(can_comment, False)
def test_any_loggedin_user_can_comment_on_open_project(self):
self._set_up_public_project_with_wiki_page(
project_options={'comment_level': 'public'})
res = self.app.get(self.public_url, auth=self.non_contributor.auth)
can_comment = res.json['data']['attributes']['current_user_can_comment']
assert_equal(res.status_code, 200)
assert_equal(can_comment, True)
def test_non_logged_in_user_cant_comment(self):
self._set_up_public_project_with_wiki_page(
project_options={'comment_level': 'public'})
res = self.app.get(self.public_url)
can_comment = res.json['data']['attributes']['current_user_can_comment']
assert_equal(res.status_code, 200)
assert_equal(can_comment, False)
def test_wiki_has_download_link(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url)
url = res.json['data']['links']['download']
expected_url = '/{}wikis/{}/content/'.format(
API_BASE, self.public_wiki_page._id)
assert_equal(res.status_code, 200)
assert_in(expected_url, url)
def test_wiki_invalid_id_not_found(self):
url = '/{}wikis/{}/'.format(API_BASE, 'abcde')
res = self.app.get(url, expect_errors=True)
assert_equal(res.status_code, 404)
def test_deleted_wiki_not_returned(self):
self._set_up_public_project_with_wiki_page()
url = '/{}wikis/{}/'.format(
API_BASE, self.public_wiki_page._id)
res = self.app.get(url)
assert_equal(res.status_code, 200)
self.public_wiki_page.deleted = datetime.datetime(2017, 3, 16, 11, 00, tzinfo=pytz.utc)
self.public_wiki_page.save()
res = self.app.get(url, expect_errors=True)
assert_equal(res.status_code, 410)
def test_public_node_wiki_relationship_links(self):
self._set_up_public_project_with_wiki_page()
res = self.app.get(self.public_url)
expected_nodes_relationship_url = '{}nodes/{}/'.format(
API_BASE, self.public_project._id)
expected_comments_relationship_url = '{}nodes/{}/comments/'.format(
API_BASE, self.public_project._id)
assert_in(
expected_nodes_relationship_url,
res.json['data']['relationships']['node']['links']['related']['href'])
assert_in(
expected_comments_relationship_url,
res.json['data']['relationships']['comments']['links']['related']['href'])
def test_private_node_wiki_relationship_links(self):
self._set_up_private_project_with_wiki_page()
res = self.app.get(self.private_url, auth=self.user.auth)
expected_nodes_relationship_url = '{}nodes/{}/'.format(
API_BASE, self.private_project._id)
expected_comments_relationship_url = '{}nodes/{}/comments/'.format(
API_BASE, self.private_project._id)
assert_in(
expected_nodes_relationship_url,
res.json['data']['relationships']['node']['links']['related']['href'])
assert_in(
expected_comments_relationship_url,
res.json['data']['relationships']['comments']['links']['related']['href'])
def test_public_registration_wiki_relationship_links(self):
self._set_up_public_registration_with_wiki_page()
res = self.app.get(self.public_registration_url)
expected_nodes_relationship_url = '{}registrations/{}/'.format(
API_BASE, self.public_registration._id)
expected_comments_relationship_url = '{}registrations/{}/comments/'.format(
API_BASE, self.public_registration._id)
assert_in(
expected_nodes_relationship_url,
res.json['data']['relationships']['node']['links']['related']['href'])
assert_in(
expected_comments_relationship_url,
res.json['data']['relationships']['comments']['links']['related']['href'])
def test_private_registration_wiki_relationship_links(self):
self._set_up_private_registration_with_wiki_page()
res = self.app.get(self.private_registration_url, auth=self.user.auth)
expected_nodes_relationship_url = '{}registrations/{}/'.format(
API_BASE, self.private_registration._id)
expected_comments_relationship_url = '{}registrations/{}/comments/'.format(
API_BASE, self.private_registration._id)
assert_in(
expected_nodes_relationship_url,
res.json['data']['relationships']['node']['links']['related']['href'])
assert_in(
expected_comments_relationship_url,
res.json['data']['relationships']['comments']['links']['related']['href'])
def test_do_not_return_disabled_wiki(self):
self._set_up_public_project_with_wiki_page()
self.public_project.delete_addon('wiki', auth=Auth(self.user))
res = self.app.get(self.public_url, expect_errors=True)
assert res.status_code == 404
def test_url_for_wiki_page_name_with_special_characters(self):
wiki = WikiFactory(user=self.user, node=self.project)
wiki.page_name = 'Wiki!@#$%^&*()+'
wiki.save()
url = '{}wiki/{}/'.format(self.project.url, wiki.page_name)
assert wiki.url == url
def registration_wiki(self, registration, user):
with mock.patch('osf.models.AbstractNode.update_search'):
return WikiFactory(
user=user,
node=registration,
)
def public_wiki(self, user, public_project):
with mock.patch('osf.models.AbstractNode.update_search'):
return WikiFactory(
user=user,
node=public_project,
)
def test_url_for_wiki_page_name_with_special_characters(self):
wiki = WikiFactory(user=self.user, node=self.project)
wiki.page_name = 'Wiki!@#$%^&*()+'
wiki.save()
url = '{}wiki/{}/'.format(self.project.url, wiki.page_name)
assert wiki.url == url
def test_url_for_wiki_page_name_with_spaces(self):
wiki = WikiFactory(user=self.user,
node=self.project,
page_name='Test Wiki')
url = '{}wiki/{}/'.format(self.project.url, wiki.page_name)
assert wiki.url == url
def test_wiki_factory(self):
wiki = WikiFactory()
assert wiki.page_name == 'home'
assert bool(wiki.user)
assert bool(wiki.node)
def setUp(self):
super(TestWikiPage, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.wiki = WikiFactory(user=self.user, node=self.project)
