def set_up_project_with_wiki_page(self):
self.project_with_wikis = ProjectFactory(creator=self.user,
is_public=True)
self.wiki = NodeWikiFactory(node=self.project_with_wikis)
self.current_wiki = NodeWikiFactory(node=self.project_with_wikis,
version=2)
return self.project_with_wikis
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
self.public_comment = CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id)
self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def test_forked_project_wiki_pages_created_post_fork_do_not_get_cloned(self):
fork_creator = AuthUserFactory()
fork = self.project.fork_node(auth=Auth(fork_creator))
wiki = NodeWikiFactory(node=fork)
current_wiki = NodeWikiFactory(node=fork, version=2, is_current=True)
main()
assert_equal(fork.wiki_pages_versions, {wiki.page_name: [wiki._id, current_wiki._id]})
assert_equal(fork.wiki_pages_current, {wiki.page_name: current_wiki._id})
def test_valid_wiki_title(self):
project = ProjectFactory()
wiki = NodeWikiFactory(node=project)
page_name = wiki.page_name
main()
wiki.reload()
assert_equal(page_name, wiki.page_name)
assert_in(page_name, project.wiki_pages_current)
assert_in(page_name, project.wiki_pages_versions)
def test_valid_wiki_title(self):
project = ProjectFactory()
wiki = NodeWikiFactory(node=project, is_current=True)
page_name = wiki.page_name
main()
wiki.reload()
assert_equal(page_name, wiki.page_name)
assert_in(page_name, project.wiki_pages_current)
assert_in(page_name, project.wiki_pages_versions)
def test_links(self):
user = AuthUserFactory()
project = ProjectFactory(creator=user)
wiki = NodeWikiFactory(
content='[[wiki2]]',
user=user,
node=project,
)
assert_in(
project.web_url_for('project_wiki_page', wname='wiki2'),
wiki.html(project),
)
def test_links(self):
user = AuthUserFactory()
project = ProjectFactory(creator=user)
wiki = NodeWikiFactory(
content='[[wiki2]]',
user=user,
node=project,
)
assert_in(
project.web_url_for('project_wiki_page', wname='wiki2'),
wiki.html(project),
)
def test_public_node_non_contributor_commenter_can_delete_wiki_comment(self):
project = ProjectFactory(is_public=True, comment_level='public')
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
def test_forward_slash_is_removed_from_wiki_title(self):
project = ProjectFactory()
wiki = NodeWikiFactory(node=project)
invalid_name = 'invalid/name'
db.nodewikipage.update({'_id': wiki._id}, {'$set': {'page_name': invalid_name}})
project.wiki_pages_current['invalid/name'] = project.wiki_pages_current[wiki.page_name]
project.wiki_pages_versions['invalid/name'] = project.wiki_pages_versions[wiki.page_name]
project.save()
main()
wiki.reload()
assert_equal(wiki.page_name, 'invalidname')
assert_in('invalidname', project.wiki_pages_current)
assert_in('invalidname', project.wiki_pages_versions)
def setUp(self):
super(TestFilterNodeWikiList, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.base_url = '/{}nodes/{}/wikis/'.format(API_BASE, self.project._id)
self.wiki = NodeWikiFactory(node=self.project, user=self.user)
self.date = self.wiki.date.strftime('%Y-%m-%dT%H:%M:%S.%f')
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
self.public_comment = CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id)
self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def test_old_wiki_versions_not_returned(self):
self._set_up_public_project_with_wiki_page()
current_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
old_version_id = self.public_project.wiki_pages_versions[current_wiki.page_name][-2]
old_version = NodeWikiPage.load(old_version_id)
url = '/{}wikis/{}/'.format(API_BASE, old_version._id)
res = self.app.get(url, expect_errors=True)
assert_equal(res.status_code, 404)
def test_public_node_non_contributor_commenter_can_update_wiki_comment(self):
project = ProjectFactory(is_public=True)
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url, payload, auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(payload['data']['attributes']['content'], res.json['data']['attributes']['content'])
def test_wiki_pages_that_do_not_exist_do_not_get_cloned(self):
project = ProjectFactory(creator=self.user, is_public=True)
wiki = NodeWikiFactory(node=project)
NodeWikiPage.remove_one(wiki._id)
# deleted wiki record in node.wiki_pages_versions
assert_in(wiki._id, project.wiki_pages_versions[wiki.page_name])
main()
project.reload()
# wiki_id gets removed from node.wiki_pages_versions
assert_not_in(wiki._id, project.wiki_pages_versions[wiki.page_name])
def test_wiki_content(self):
project = ProjectFactory(creator=self.user)
wiki_page = 'home'
wiki_content = 'Kittens'
NodeWikiFactory(user=self.user, node=project, content=wiki_content, page_name=wiki_page)
res = self.app.get('/{0}/wiki/{1}/'.format(
project._primary_key,
wiki_page,
), auth=self.auth)
assert_not_in('No wiki content', res)
assert_in(wiki_content, res)
def test_public_node_non_contributor_commenter_cannot_update_own_wiki_comment_if_comment_level_private(self):
project = ProjectFactory(is_public=True)
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url, payload, 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_forward_slash_is_removed_from_wiki_title(self):
project = ProjectFactory()
wiki = NodeWikiFactory(node=project, is_current=True)
invalid_name = 'invalid/name'
db.nodewikipage.update({'_id': wiki._id},
{'$set': {
'page_name': invalid_name
}})
project.wiki_pages_current[
'invalid/name'] = project.wiki_pages_current[wiki.page_name]
project.wiki_pages_versions[
'invalid/name'] = project.wiki_pages_versions[wiki.page_name]
project.save()
main()
wiki.reload()
assert_equal(wiki.page_name, 'invalidname')
assert_in('invalidname', project.wiki_pages_current)
assert_in('invalidname', project.wiki_pages_versions)
def _set_up_public_project_comment_reports(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
self.public_comment = CommentFactory.build(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.contributor)
self.public_comment.reports = {self.user._id: {
'category': 'spam',
'text': 'This is spam',
'date': datetime.utcnow(),
'retracted': False,
}}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/{}/'.format(API_BASE, self.public_comment._id, self.user._id)
def _set_up_registration_with_comment(self):
self.registration = RegistrationFactory(creator=self.user,
comment_level='private')
self.registration_wiki = NodeWikiFactory(node=self.registration,
user=self.user)
self.registration_comment = CommentFactory(
node=self.registration,
target=Guid.load(self.registration_wiki._id),
user=self.user)
self.comment_url = '/{}comments/{}/'.format(
API_BASE, self.registration_comment._id)
reply_target = Guid.load(self.registration_comment._id)
self.registration_comment_reply = CommentFactory(
node=self.registration, target=reply_target, user=self.user)
def setUp(self):
super(TestShortUrls, self).setUp()
self.user = AuthUserFactory()
self.auth = self.user.auth
self.consolidate_auth = Auth(user=self.user)
self.project = ProjectFactory(creator=self.user)
# A non-project componenet
self.component = NodeFactory(category='hypothesis', creator=self.user)
self.project.nodes.append(self.component)
self.component.save()
# Hack: Add some logs to component; should be unnecessary pending
# improvements to factories from @rliebz
self.component.set_privacy('public', auth=self.consolidate_auth)
self.component.set_privacy('private', auth=self.consolidate_auth)
self.wiki = NodeWikiFactory(user=self.user, node=self.component)
def setUp(self):
super(TestShortUrls, self).setUp()
self.user = UserFactory()
# Add an API key for quicker authentication
api_key = ApiKeyFactory()
self.user.api_keys.append(api_key)
self.user.save()
self.auth = ('test', api_key._primary_key)
self.consolidate_auth = Auth(user=self.user, api_key=api_key)
self.project = ProjectFactory(creator=self.user)
# A non-project componenet
self.component = NodeFactory(category='hypothesis', creator=self.user)
self.project.nodes.append(self.component)
self.component.save()
# Hack: Add some logs to component; should be unnecessary pending
# improvements to factories from @rliebz
self.component.set_privacy('public', auth=self.consolidate_auth)
self.component.set_privacy('private', auth=self.consolidate_auth)
self.wiki = NodeWikiFactory(user=self.user, node=self.component)
def test_wiki_pages_with_invalid_nodes_are_removed_after_cloning(self):
project = ProjectFactory(creator=self.user, is_public=True)
wiki = NodeWikiFactory(node=project)
fork = project.fork_node(auth=Auth(self.user))
fork.wiki_pages_versions = project.wiki_pages_versions
fork.wiki_pages_current = project.wiki_pages_current
fork.save()
# Remove original node - wiki.node no longer points to an existing project
Node.remove_one(project._id)
# clone wiki page
main()
fork.reload()
cloned_wiki_id = fork.wiki_pages_versions[wiki.page_name][0]
cloned_wiki = NodeWikiPage.load(cloned_wiki_id)
assert_equal(cloned_wiki.node._id, fork._id)
# move original wiki page to unmigratedwikipages collection
assert_false(db.nodewikipage.find_one({'_id': wiki._id}))
assert_true(db.unmigratedwikipages.find_one({'_id': wiki._id}))
class TestWikiCommentDetailView(CommentDetailMixin, ApiTestCase):
def _set_up_private_project_with_comment(self):
self.private_project = ProjectFactory.create(is_public=False, creator=self.user, comment_level='private')
self.private_project.add_contributor(self.contributor, save=True)
self.wiki = NodeWikiFactory(node=self.private_project, user=self.user)
self.comment = CommentFactory(node=self.private_project, target=Guid.load(self.wiki._id), user=self.user)
self.private_url = '/{}comments/{}/'.format(API_BASE, self.comment._id)
self.payload = self._set_up_payload(self.comment._id)
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user)
self.public_comment = CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user)
reply_target = Guid.load(self.public_comment._id)
self.public_comment_reply = CommentFactory(node=self.public_project, target=reply_target, user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id)
self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def _set_up_registration_with_comment(self):
self.registration = RegistrationFactory(creator=self.user, comment_level='private')
self.registration_wiki = NodeWikiFactory(node=self.registration, user=self.user)
self.registration_comment = CommentFactory(node=self.registration, target=Guid.load(self.registration_wiki._id), user=self.user)
self.comment_url = '/{}comments/{}/'.format(API_BASE, self.registration_comment._id)
reply_target = Guid.load(self.registration_comment._id)
self.registration_comment_reply = CommentFactory(node=self.registration, target=reply_target, user=self.user)
def test_wiki_comment_has_target_link_with_correct_type(self):
self._set_up_public_project_with_comment()
res = self.app.get(self.public_url)
url = res.json['data']['relationships']['target']['links']['related']['href']
expected_url = self.public_wiki.get_absolute_url()
target_type = res.json['data']['relationships']['target']['links']['related']['meta']['type']
expected_type = 'wiki'
assert_equal(res.status_code, 200)
assert_equal(url, expected_url)
assert_equal(target_type, expected_type)
def test_public_node_non_contributor_commenter_can_update_wiki_comment(self):
project = ProjectFactory(is_public=True)
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url, payload, auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(payload['data']['attributes']['content'], res.json['data']['attributes']['content'])
def test_public_node_non_contributor_commenter_cannot_update_own_wiki_comment_if_comment_level_private(self):
project = ProjectFactory(is_public=True)
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url, payload, 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_public_node_non_contributor_commenter_can_delete_wiki_comment(self):
project = ProjectFactory(is_public=True, comment_level='public')
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
def test_comment_detail_for_deleted_wiki_is_not_returned(self):
self._set_up_private_project_with_comment()
# Delete commented wiki page
self.private_project.delete_node_wiki(self.wiki.page_name, core.Auth(self.user))
res = self.app.get(self.private_url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 404)
def _add_project_wiki_page(self, node, user):
from tests.factories import NodeWikiFactory
# API will only return current wiki pages
return NodeWikiFactory(node=node, user=user)
def test_bad_links(self):
content = u'<span></span><iframe src="http://httpbin.org/"></iframe>'
node = ProjectFactory()
wiki = NodeWikiFactory(content=content, node=node)
expected = render_content(content, node)
assert_equal(expected, wiki.html(node))
def test_redirect_throws_501_for_non_implemented_views(self):
wiki = NodeWikiFactory()
url = '/{}guids/{}/'.format(API_BASE, wiki._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 501)
class TestWikiCommentDetailView(CommentDetailMixin, ApiTestCase):
def _set_up_private_project_with_comment(self):
self.private_project = ProjectFactory.create(is_public=False,
creator=self.user,
comment_level='private')
self.private_project.add_contributor(self.contributor, save=True)
self.wiki = NodeWikiFactory(node=self.private_project, user=self.user)
self.comment = CommentFactory(node=self.private_project,
target=Guid.load(self.wiki._id),
user=self.user)
self.private_url = '/{}comments/{}/'.format(API_BASE, self.comment._id)
self.payload = self._set_up_payload(self.comment._id)
def _set_up_public_project_with_comment(self):
self.public_project = ProjectFactory.create(is_public=True,
creator=self.user,
comment_level='private')
self.public_project.add_contributor(self.contributor, save=True)
self.public_wiki = NodeWikiFactory(node=self.public_project,
user=self.user)
self.public_comment = CommentFactory(node=self.public_project,
target=Guid.load(
self.public_wiki._id),
user=self.user)
self.public_url = '/{}comments/{}/'.format(API_BASE,
self.public_comment._id)
self.public_comment_payload = self._set_up_payload(
self.public_comment._id)
def _set_up_registration_with_comment(self):
self.registration = RegistrationFactory(creator=self.user,
comment_level='private')
self.registration_wiki = NodeWikiFactory(node=self.registration,
user=self.user)
self.registration_comment = CommentFactory(
node=self.registration,
target=Guid.load(self.registration_wiki._id),
user=self.user)
self.comment_url = '/{}comments/{}/'.format(
API_BASE, self.registration_comment._id)
reply_target = Guid.load(self.registration_comment._id)
self.registration_comment_reply = CommentFactory(
node=self.registration, target=reply_target, user=self.user)
def test_wiki_comment_has_target_link_with_correct_type(self):
self._set_up_public_project_with_comment()
res = self.app.get(self.public_url)
url = res.json['data']['relationships']['target']['links']['related'][
'href']
expected_url = self.public_wiki.get_absolute_url()
target_type = res.json['data']['relationships']['target']['links'][
'related']['meta']['type']
expected_type = 'wiki'
assert_equal(res.status_code, 200)
assert_equal(url, expected_url)
assert_equal(target_type, expected_type)
def test_public_node_non_contributor_commenter_can_update_wiki_comment(
self):
project = ProjectFactory(is_public=True)
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project,
target=Guid.load(test_wiki),
user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url,
payload,
auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(payload['data']['attributes']['content'],
res.json['data']['attributes']['content'])
def test_public_node_non_contributor_commenter_cannot_update_own_wiki_comment_if_comment_level_private(
self):
project = ProjectFactory(is_public=True)
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project,
target=Guid.load(test_wiki),
user=self.non_contributor)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url,
payload,
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_public_node_non_contributor_commenter_can_delete_wiki_comment(
self):
project = ProjectFactory(is_public=True, comment_level='public')
test_wiki = NodeWikiFactory(node=project, user=self.user)
comment = CommentFactory(node=project,
target=Guid.load(test_wiki),
user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
def test_comment_detail_for_deleted_wiki_is_not_returned(self):
self._set_up_private_project_with_comment()
# Delete commented wiki page
self.private_project.delete_node_wiki(self.wiki.page_name,
core.Auth(self.user))
res = self.app.get(self.private_url,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 404)
def test_bad_links(self):
content = u'<span></span><iframe src="http://httpbin.org/"></iframe>'
node = ProjectFactory()
wiki = NodeWikiFactory(content=content, node=node)
expected = render_content(content, node)
assert_equal(expected, wiki.html(node))
