def test_topic_notification_list(self):
"""
topic notification list
"""
utils.login(self)
response = self.client.get(reverse('spirit:topic-notification-list'))
self.assertQuerysetEqual(response.context['notifications'], map(repr, [self.topic_notification, ]))
def test_advanced_search_detail(self):
"""
advanced search by topic
"""
utils.login(self)
response = self.client.get(reverse('spirit:search'))
self.assertEqual(response.status_code, 200)
def setUp(self):
self.driver = webdriver.Firefox()
self.driver.implicitly_wait(10)
self.base_url = "http://127.0.0.1:8000"
self.verificationErrors = []
self.accept_next_alert = True
utils.login(self.driver)
def test_topic_unread_list_empty_page(self):
"""
empty page, other than the first one
"""
utils.login(self)
response = self.client.get(reverse('spirit:topic-unread-list') + "?topic_id=" + str(self.topic.pk))
self.assertEqual(response.status_code, 404)
def test_login_fail(temp_app, temp_db):
'''Tests various login failure cases'''
# Tests trying to log in with no email
res = login({'password': '******'}, temp_app)
res_data = json.loads(res.data)
assert res.status_code == 400, 'Response code should be 400 - BAD REQUEST'
assert isinstance(res_data, dict), 'Response data must be in json'
assert res_data['error'] == 'Login request must have email and password'
# Tests trying to log in with no password
res = login({'email': '*****@*****.**'}, temp_app)
res_data = json.loads(res.data)
assert res.status_code == 400, 'Response code should be 400 - BAD REQUEST'
assert isinstance(res_data, dict), 'Response data must be in json'
assert res_data['error'] == 'Login request must have email and password'
# Tests trying to log in with the wrong password
user = {'email': '*****@*****.**', 'password': '******'}
res = login(user, temp_app)
res_data = json.loads(res.data)
assert res.status_code == 400, 'Response code should be 400 - BAD REQUEST'
assert isinstance(res_data, dict), 'Response data must be in json'
assert res_data['error'] == 'Invalid email address or password'
# Tests trying to log in with the wrong email
user = {'email': '*****@*****.**', 'password': '******'}
res = login(user, temp_app)
res_data = json.loads(res.data)
assert res.status_code == 400, 'Response code should be 400 - BAD REQUEST'
assert isinstance(res_data, dict), 'Response data must be in json'
assert res_data['error'] == 'Invalid email address or password'
def test_private_publish_topic_private_post_create_signals(self):
"""
send topic_private_post_create signal
"""
def topic_private_post_create_handler(sender, topics_private, comment,
**kwargs):
self.assertEqual(len(topics_private), 1)
tp = topics_private[0]
self._topic = repr(tp.topic)
self._user = repr(tp.user)
self._comment = repr(comment)
topic_private_post_create.connect(topic_private_post_create_handler)
utils.login(self)
form_data = {
'comment': 'foo',
'title': 'foobar',
'users': self.user.username
}
response = self.client.post(reverse('spirit:private-publish'),
form_data)
self.assertEqual(response.status_code, 302)
topic_private = TopicPrivate.objects.last()
topic_comment = Comment.objects.last()
self.assertEqual(self._topic, repr(topic_private.topic))
self.assertEqual(self._user, repr(self.user))
self.assertEqual(self._comment, repr(topic_comment))
def test_topic_update_signal(self):
"""
POST, topic moved to category
"""
def topic_post_moderate_handler(sender, user, topic, action, **kwargs):
self._moderate = [repr(user._wrapped), repr(topic), action]
topic_post_moderate.connect(topic_post_moderate_handler)
utils.login(self)
self.user.is_moderator = True
self.user.save()
category = utils.create_category()
topic = utils.create_topic(category=category, user=self.user)
category2 = utils.create_category()
form_data = {'title': 'foobar', 'category': category2.pk}
response = self.client.post(
reverse('spirit:topic-update', kwargs={
'pk': topic.pk,
}), form_data)
self.assertSequenceEqual(
self._moderate,
[repr(self.user),
repr(Topic.objects.get(pk=topic.pk)), MOVED])
def test_private_publish_user(self):
"""
create private topic with user as initial value
"""
utils.login(self)
response = self.client.get(reverse('spirit:private-publish', kwargs={'user_id': self.user2.pk, }))
self.assertEqual(response.context['tpform'].initial['users'], [self.user2.username, ])
def test_user_admins(self):
"""
List of admins
"""
utils.login(self)
response = self.client.get(reverse('spirit:admin-user-admins'))
self.assertQuerysetEqual(response.context['users'], map(repr, [self.user, ]))
def test_comment_image_upload(self):
"""
comment image upload
"""
utils.login(self)
img = StringIO('GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
files = {
'image':
SimpleUploadedFile('image.gif',
img.read(),
content_type='image/gif'),
}
response = self.client.post(
reverse('spirit:comment-image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content)
self.assertEqual(
res['url'],
os.path.join(settings.MEDIA_URL, 'spirit', 'images',
str(self.user.pk),
"bf21c3043d749d5598366c26e7e4ab44.gif").replace(
"\\", "/"))
os.remove(
os.path.join(settings.MEDIA_ROOT, 'spirit', 'images',
str(self.user.pk),
"bf21c3043d749d5598366c26e7e4ab44.gif"))
def test_topic_moderate_unpin(self):
"""
topic unpin
"""
def topic_post_moderate_handler(sender, user, topic, action, **kwargs):
self._moderate = [repr(user._wrapped), repr(topic), action]
topic_post_moderate.connect(topic_post_moderate_handler)
utils.login(self)
self.user.is_moderator = True
self.user.save()
category = utils.create_category()
topic = utils.create_topic(category, is_pinned=True)
form_data = {}
response = self.client.post(
reverse('spirit:topic-unpin', kwargs={
'pk': topic.pk,
}), form_data)
expected_url = topic.get_absolute_url()
self.assertRedirects(response, expected_url, status_code=302)
self.assertFalse(Topic.objects.get(pk=topic.pk).is_pinned)
self.assertEqual(
self._moderate,
[repr(self.user), repr(topic), UNPINNED])
def test_profile_likes_dont_show_removed_or_private(self):
"""
dont show private topics or removed
"""
category = utils.create_category()
category_removed = utils.create_category(is_removed=True)
subcategory = utils.create_category(parent=category_removed)
subcategory_removed = utils.create_category(parent=category, is_removed=True)
topic_a = utils.create_private_topic(user=self.user2)
topic_b = utils.create_topic(category=category, is_removed=True)
topic_c = utils.create_topic(category=category_removed)
topic_d = utils.create_topic(category=subcategory)
topic_e = utils.create_topic(category=subcategory_removed)
comment_a = utils.create_comment(user=self.user2, topic=topic_a.topic)
comment_b = utils.create_comment(user=self.user, topic=topic_b)
comment_c = utils.create_comment(user=self.user, topic=topic_c)
comment_d = utils.create_comment(user=self.user, topic=topic_d)
comment_e = utils.create_comment(user=self.user, topic=topic_e)
like_a = CommentLike.objects.create(user=self.user2, comment=comment_a)
like_b = CommentLike.objects.create(user=self.user2, comment=comment_b)
like_c = CommentLike.objects.create(user=self.user2, comment=comment_c)
like_d = CommentLike.objects.create(user=self.user2, comment=comment_d)
like_e = CommentLike.objects.create(user=self.user2, comment=comment_e)
utils.login(self)
response = self.client.get(reverse("spirit:profile-likes", kwargs={'pk': self.user2.pk,
'slug': self.user2.slug}))
self.assertQuerysetEqual(response.context['comments'], [])
def test_user_edit(self):
"""
Edit user profile
"""
utils.login(self)
form_data = {
"username": "******",
"email": "*****@*****.**",
"location": "Bs As",
"timezone": "UTC",
"is_administrator": True,
"is_moderator": True,
"is_active": True
}
response = self.client.post(
reverse('spirit:admin-user-edit',
kwargs={
'user_id': self.user.pk,
}), form_data)
expected_url = reverse('spirit:admin-user-edit',
kwargs={
'user_id': self.user.pk,
})
self.assertRedirects(response, expected_url, status_code=302)
response = self.client.get(
reverse('spirit:admin-user-edit',
kwargs={
'user_id': self.user.pk,
}))
self.assertEqual(response.status_code, 200)
def test_topic_publish_invalid_category(self):
"""
invalid topic category
"""
utils.login(self)
response = self.client.get(reverse('spirit:topic-publish', kwargs={'category_id': str(99), }))
self.assertEqual(response.status_code, 404)
def test_logout(self):
"""
should log out on POST only
"""
utils.login(self)
# get should display confirmation message
response = self.client.get(reverse('spirit:user-logout'))
self.assertEqual(response.status_code, 200)
self.assertTrue(self.client.session.items())
# post should log out the user (clear the session)
response = self.client.post(reverse('spirit:user-logout'))
expected_url = "/"
self.assertRedirects(response, expected_url, status_code=302)
self.assertFalse(self.client.session.items())
# next
utils.login(self)
self.assertTrue(self.client.session.items())
response = self.client.post(
reverse('spirit:user-logout') + '?next=/fakepath/')
self.assertRedirects(response,
'/fakepath/',
status_code=302,
target_status_code=404)
self.assertFalse(self.client.session.items())
def test_category_update(self):
"""
Category update
"""
utils.login(self)
form_data = {
"parent": "",
"title": "foo",
"description": "",
"is_closed": False,
"is_removed": False
}
response = self.client.post(
reverse('spirit:admin-category-update',
kwargs={
"category_id": self.category.pk,
}), form_data)
expected_url = reverse("spirit:admin-category-list")
self.assertRedirects(response, expected_url, status_code=302)
response = self.client.get(
reverse('spirit:admin-category-update',
kwargs={
"category_id": self.category.pk,
}))
self.assertEqual(response.status_code, 200)
def test_client_secret_post_authentication(oidc_settings, app, simple_oidc_client, simple_user):
utils.login(app, simple_user)
redirect_uri = simple_oidc_client.redirect_uris.split()[0]
params = {
'client_id': simple_oidc_client.client_id,
'scope': 'openid profile email',
'redirect_uri': redirect_uri,
'state': 'xxx',
'nonce': 'yyy',
'response_type': 'code',
}
authorize_url = make_url('oidc-authorize', params=params)
response = app.get(authorize_url)
response = response.form.submit('accept')
location = urlparse.urlparse(response['Location'])
query = urlparse.parse_qs(location.query)
code = query['code'][0]
token_url = make_url('oidc-token')
response = app.post(token_url, params={
'grant_type': 'authorization_code',
'code': code,
'redirect_uri': redirect_uri,
'client_id': simple_oidc_client.client_id,
'client_secret': simple_oidc_client.client_secret,
})
assert 'error' not in response.json
assert 'access_token' in response.json
assert 'expires_in' in response.json
assert 'id_token' in response.json
assert response.json['token_type'] == 'Bearer'
def test_compare_nodes(self):
nodes = 3
amounts1 = utils.getUserTokenAmounts(host1, db1, login1, pas1)
amounts2 = utils.getUserTokenAmounts(host2, db2, login2, pas2)
amounts3 = utils.getUserTokenAmounts(host3, db3, login3, pas3)
sumAmounts = sum(amount[0] for amount in amounts1)
self.data1 = utils.login(config1["url"], config1['private_key'], 0)
maxBlockId1 = funcs.get_max_block_id(config1["url"],
self.data1["jwtToken"])
self.data2 = utils.login(config2["url"], config1['private_key'], 0)
maxBlockId2 = funcs.get_max_block_id(config2["url"],
self.data2["jwtToken"])
self.data3 = utils.login(config3["url"], config1['private_key'], 0)
maxBlockId3 = funcs.get_max_block_id(config3["url"],
self.data3["jwtToken"])
maxBlock = max(maxBlockId2, maxBlockId1, maxBlockId3)
hash1 = utils.get_blockchain_hash(host1, db1, login1, pas1, maxBlock)
hash2 = utils.get_blockchain_hash(host2, db2, login2, pas2, maxBlock)
hash3 = utils.get_blockchain_hash(host3, db3, login3, pas3, maxBlock)
node_position = utils.compare_node_positions(host1, db1, login1, pas1,
maxBlock, nodes)
dict1 = dict(amounts=str(amounts1),
hash=str(hash1),
node_pos=str(node_position))
dict2 = dict(amounts=str(amounts2), hash=str(hash2), node_pos="True")
dict3 = dict(amounts=str(amounts3), hash=str(hash3), node_pos="True")
msg = "Test three nodes is faild. contracts: \n"
msg += str(amounts1) + str(hash1) + "\n"
msg += str(amounts2) + str(hash2) + "\n"
msg += str(amounts3) + str(hash3) + str(node_position) + "\n"
msg += "Amounts summ: " + str(sumAmounts)
self.assertDictEqual(dict1, dict2, msg)
self.assertDictEqual(dict1, dict3, msg)
def test_block_chain(self):
fullConfig = config.getNodeConfig()
nodes = len(fullConfig)
config1 = fullConfig["1"]
config2 = fullConfig["2"]
db1 = config1["dbName"]
db2 = config2["dbName"]
login1 = config1["login"]
login2 = config2["login"]
pas1 = config1["pass"]
pas2 = config2["pass"]
host1 = config1["dbHost"]
host2 = config2["dbHost"]
ts_count = 30
self.data1 = utils.login(config1["url"], config1['private_key'], 0)
i = 1
amountsB = utils.getUserTokenAmounts(host1, db1, login1, pas1)
sumAmountsBefore = sum(amount[0] for amount in amountsB)
while i < ts_count:
contName = self.create_contract(
config1["url"],
config1['private_key'],
)
i = i + 1
time.sleep(1)
time.sleep(120)
count_contracts1 = utils.getCountDBObjects(host1, db1, login1,
pas1)["contracts"]
count_contracts2 = utils.getCountDBObjects(host2, db2, login2,
pas2)["contracts"]
amounts1 = utils.getUserTokenAmounts(host1, db1, login1, pas1)
amounts2 = utils.getUserTokenAmounts(host2, db2, login2, pas2)
sumAmounts = sum(amount[0] for amount in amounts1)
maxBlockId1 = funcs.get_max_block_id(config1["url"],
self.data1["jwtToken"])
self.data2 = utils.login(config2["url"], config1['private_key'], 0)
maxBlockId2 = funcs.get_max_block_id(config2["url"],
self.data2["jwtToken"])
maxBlock = max(maxBlockId2, maxBlockId1)
hash1 = utils.get_blockchain_hash(host1, db1, login1, pas1, maxBlock)
hash2 = utils.get_blockchain_hash(host2, db2, login2, pas2, maxBlock)
node_position = utils.compare_node_positions(host1, db1, login1, pas1,
maxBlock, nodes)
dict1 = dict(count_contract=count_contracts1,
amounts=str(amounts1),
summ=str(sumAmounts),
hash=str(hash1),
node_pos=str(node_position))
dict2 = dict(count_contract=count_contracts2,
amounts=str(amounts2),
summ=str(sumAmountsBefore),
hash=str(hash2),
node_pos="True")
msg = "Test two_nodes is faild. contracts: \n"
msg += str(count_contracts1) + str(amounts1) + str(hash1) + str(
node_position) + "\n"
msg += str(count_contracts2) + str(amounts1) + str(hash1) + str(
node_position) + "\n"
msg += "Amounts summ: " + str(sumAmounts)
self.assertDictEqual(dict1, dict2, msg)
def test_advanced_search_detail(self):
"""
advanced search by topic
"""
utils.login(self)
response = self.client.get(reverse('spirit:search'))
self.assertEqual(response.status_code, 200)
def test_user_admin(db, app, superuser):
utils.login(app, superuser)
Attribute.objects.create(label='SIRET',
name='siret',
kind='string',
required=False,
user_visible=True,
user_editable=False,
asked_on_registration=False,
multiple=False)
Attribute.objects.create(label='Civilité',
name='civilite',
kind='title',
required=False,
user_visible=True,
user_editable=True,
asked_on_registration=True,
multiple=False)
resp = app.get('/admin/custom_user/user/%s/' % superuser.pk).maybe_follow()
assert set(resp.form.fields.keys()) >= set([
'username', 'first_name', 'last_name', 'civilite', 'siret', 'is_staff',
'is_superuser', 'ou', 'groups', 'date_joined_0', 'date_joined_1',
'last_login_0', 'last_login_1'
])
resp.form.set('first_name', 'John')
resp.form.set('last_name', 'Doe')
resp.form.set('civilite', 'Mr')
resp.form.set('siret', '1234')
resp = resp.form.submit('_continue').follow()
modified_admin = User.objects.get(pk=superuser.pk)
assert modified_admin.first_name == 'John'
assert modified_admin.last_name == 'Doe'
assert modified_admin.attributes.civilite == 'Mr'
assert modified_admin.attributes.siret == '1234'
def test_register(self):
"""
register
"""
# get
response = self.client.get(reverse('spirit:user-register'))
self.assertEqual(response.status_code, 200)
# post
form_data = {
'username': '******',
'email': '*****@*****.**',
'password1': 'pass',
'password2': 'pass'
}
response = self.client.post(reverse('spirit:user-register'), form_data)
expected_url = reverse('spirit:user-login')
self.assertRedirects(response, expected_url, status_code=302)
# redirect logged in user
utils.login(self)
response = self.client.get(reverse('spirit:user-register'))
self.assertRedirects(response,
reverse('spirit:profile-update'),
status_code=302)
def test_create_call(settings, page):
"Test login, create, delete a call."
utils.login(settings, page, admin=True)
# Create a call.
page.goto(settings["BASE_URL"])
page.click("text=Calls")
page.click("text=My calls")
assert page.url == f"{settings['BASE_URL']}/calls/owner/{settings['ADMIN_USERNAME']}"
page.click("text=Create")
assert page.url == f"{settings['BASE_URL']}/call/"
page.click('input[name="identifier"]')
page.fill('input[name="identifier"]', "TEST")
page.click('input[name="title"]')
page.fill('input[name="title"]', "Test call")
page.click("#create")
assert page.url == f"{settings['BASE_URL']}/call/TEST/edit"
page.click('textarea[name="description"]')
page.fill('textarea[name="description"]', "This is a test call.")
page.click("text=Save")
assert page.url == f"{settings['BASE_URL']}/call/TEST"
# Delete the call.
page.goto(settings["BASE_URL"])
page.click("text=Calls")
page.click("text=My calls")
assert page.url == f"{settings['BASE_URL']}/calls/owner/{settings['ADMIN_USERNAME']}"
page.click("text=TEST")
assert page.url == f"{settings['BASE_URL']}/call/TEST"
page.once("dialog",
lambda dialog: dialog.accept()) # Callback for next click.
page.click("text=Delete")
assert page.url == f"{settings['BASE_URL']}/calls/owner/{settings['ADMIN_USERNAME']}"
def test_comment_update_signal(self):
"""
update comment, emit signal
"""
def comment_pre_update_handler(sender, comment, **kwargs):
self._comment_old = comment
comment_pre_update.connect(comment_pre_update_handler)
def comment_post_update_handler(sender, comment, **kwargs):
self._comment_new = comment
comment_post_update.connect(comment_post_update_handler)
utils.login(self)
comment_posted = utils.create_comment(user=self.user, topic=self.topic)
form_data = {
'comment': 'barfoo',
}
response = self.client.post(
reverse('spirit:comment-update',
kwargs={
'pk': comment_posted.pk,
}), form_data)
self.assertEqual(repr(self._comment_new),
repr(Comment.objects.get(pk=comment_posted.pk)))
self.assertEqual(repr(self._comment_old), repr(comment_posted))
def test_topic_notification_list_unread(self):
"""
topic notification list
"""
topic = utils.create_topic(self.category, user=self.user2)
comment = utils.create_comment(topic=topic, user=self.user2)
topic_notification = TopicNotification.objects.create(user=self.user,
topic=topic,
comment=comment,
is_active=True,
action=COMMENT)
utils.login(self)
response = self.client.get(
reverse('spirit:topic-notification-list-unread'))
self.assertQuerysetEqual(
response.context['page'],
map(repr, [topic_notification, self.topic_notification]))
# fake next page
response = self.client.get(
reverse('spirit:topic-notification-list-unread') + "?notif=" +
str(topic_notification.pk))
self.assertQuerysetEqual(response.context['page'],
map(repr, [
self.topic_notification,
]))
def test_comment_move_signal(self):
"""
move comments, emit signal
"""
self._comments = []
def comment_posted_handler(sender, comment, **kwargs):
self._comments.append(comment)
comment_posted.connect(comment_posted_handler)
def comment_moved_handler(sender, comments, topic_from, **kwargs):
self._comment_count = len(comments)
self._topic_from = topic_from
comment_moved.connect(comment_moved_handler)
utils.login(self)
self.user.is_moderator = True
self.user.save()
comment = utils.create_comment(user=self.user, topic=self.topic)
comment2 = utils.create_comment(user=self.user, topic=self.topic)
to_topic = utils.create_topic(self.category)
form_data = {'topic': to_topic.pk,
'comments': [comment.pk, comment2.pk], }
response = self.client.post(reverse('spirit:comment-move', kwargs={'topic_id': self.topic.pk, }),
form_data)
self.assertEqual(response.status_code, 302)
self.assertListEqual(self._comments, [comment2, comment])
self.assertEqual(self._comment_count, 2)
self.assertEqual(repr(self._topic_from), repr(self.topic))
def test_comment_update(self):
"""
update comment
"""
comment = utils.create_comment(user=self.user, topic=self.topic)
utils.login(self)
form_data = {
'comment': 'barfoo',
}
response = self.client.post(
reverse('spirit:comment-update', kwargs={
'pk': comment.pk,
}), form_data)
expected_url = reverse('spirit:comment-find', kwargs={
'pk': 1,
})
self.assertRedirects(response,
expected_url,
status_code=302,
target_status_code=302)
self.assertEqual(Comment.objects.get(pk=comment.pk).comment, 'barfoo')
# next
form_data.update({
'next': '/fakepath/',
})
response = self.client.post(
reverse('spirit:comment-update', kwargs={
'pk': comment.pk,
}), form_data)
self.assertRedirects(response,
'/fakepath/',
status_code=302,
target_status_code=404)
def test_profile_topics_order(self):
"""
topics ordered by date
"""
Topic.objects.all().delete()
category = utils.create_category()
topic_a = utils.create_topic(category=category, user=self.user2)
topic_b = utils.create_topic(category=category, user=self.user2)
topic_c = utils.create_topic(category=category, user=self.user2)
Topic.objects.filter(pk=topic_a.pk).update(date=timezone.now() -
datetime.timedelta(days=10))
Topic.objects.filter(pk=topic_c.pk).update(date=timezone.now() -
datetime.timedelta(days=5))
utils.login(self)
response = self.client.get(
reverse("spirit:profile-topics",
kwargs={
'pk': self.user2.pk,
'slug': self.user2.slug
}))
self.assertQuerysetEqual(response.context['topics'],
map(repr, [topic_b, topic_c, topic_a]))
def test_private_publish_user(self):
"""
create private topic with user as initial value
"""
utils.login(self)
response = self.client.get(reverse('spirit:private-publish', kwargs={'user_id': self.user2.pk, }))
self.assertEqual(response.context['tpform'].initial['users'], [self.user2.username, ])
def test_profile_topics_dont_show_removed_or_private(self):
"""
dont show private topics or removed
"""
Topic.objects.all().delete()
category = utils.create_category()
category_removed = utils.create_category(is_removed=True)
subcategory = utils.create_category(parent=category_removed)
subcategory_removed = utils.create_category(parent=category,
is_removed=True)
topic_a = utils.create_private_topic(user=self.user2)
topic_b = utils.create_topic(category=category,
user=self.user2,
is_removed=True)
topic_c = utils.create_topic(category=category_removed,
user=self.user2)
topic_d = utils.create_topic(category=subcategory, user=self.user2)
topic_e = utils.create_topic(category=subcategory_removed,
user=self.user2)
utils.login(self)
response = self.client.get(
reverse("spirit:profile-topics",
kwargs={
'pk': self.user2.pk,
'slug': self.user2.slug
}))
self.assertQuerysetEqual(response.context['topics'], [])
def test_topic_publish_in_category(self):
"""
POST, create topic in category
"""
utils.login(self)
category = utils.create_category()
form_data = {
'comment': 'foo',
'title': 'foobar',
'category': category.pk
}
response = self.client.post(
reverse('spirit:topic-publish',
kwargs={
'category_id': category.pk,
}), form_data)
topic = Topic.objects.last()
expected_url = topic.get_absolute_url()
self.assertRedirects(response, expected_url, status_code=302)
# ratelimit
response = self.client.post(
reverse('spirit:topic-publish',
kwargs={
'category_id': category.pk,
}), form_data)
self.assertEqual(response.status_code, 200)
def test_private_publish_user(self):
"""
create private topic with user as initial value
"""
utils.login(self)
response = self.client.get(reverse("spirit:private-publish", kwargs={"user_id": self.user2.pk}))
self.assertEqual(response.context["tpform"].initial["users"], [self.user2.username])
def test_topic_detail_view_signals(self):
"""
send topic view signal
"""
def topic_viewed_handler(sender, request, topic, **kwargs):
self._viewed = [
request,
repr(topic),
]
topic_viewed.connect(topic_viewed_handler)
utils.login(self)
category = utils.create_category()
topic = utils.create_topic(category=category, user=self.user)
response = self.client.get(
reverse('spirit:topic-detail',
kwargs={
'pk': topic.pk,
'slug': topic.slug
}))
self.assertEqual(response.status_code, 200)
self.assertSequenceEqual(self._viewed,
[response.context['request'],
repr(topic)])
def test_profile_likes_dont_show_removed_or_private(self):
"""
dont show private topics or removed
"""
category = utils.create_category()
category_removed = utils.create_category(is_removed=True)
subcategory = utils.create_category(parent=category_removed)
subcategory_removed = utils.create_category(parent=category,
is_removed=True)
topic_a = utils.create_private_topic(user=self.user2)
topic_b = utils.create_topic(category=category, is_removed=True)
topic_c = utils.create_topic(category=category_removed)
topic_d = utils.create_topic(category=subcategory)
topic_e = utils.create_topic(category=subcategory_removed)
comment_a = utils.create_comment(user=self.user2, topic=topic_a.topic)
comment_b = utils.create_comment(user=self.user, topic=topic_b)
comment_c = utils.create_comment(user=self.user, topic=topic_c)
comment_d = utils.create_comment(user=self.user, topic=topic_d)
comment_e = utils.create_comment(user=self.user, topic=topic_e)
like_a = CommentLike.objects.create(user=self.user2, comment=comment_a)
like_b = CommentLike.objects.create(user=self.user2, comment=comment_b)
like_c = CommentLike.objects.create(user=self.user2, comment=comment_c)
like_d = CommentLike.objects.create(user=self.user2, comment=comment_d)
like_e = CommentLike.objects.create(user=self.user2, comment=comment_e)
utils.login(self)
response = self.client.get(
reverse("spirit:profile-likes",
kwargs={
'pk': self.user2.pk,
'slug': self.user2.slug
}))
self.assertQuerysetEqual(response.context['comments'], [])
def test_profile_likes_order(self):
"""
comments ordered by date
"""
comment_a = utils.create_comment(user=self.user, topic=self.topic)
comment_b = utils.create_comment(user=self.user, topic=self.topic)
comment_c = utils.create_comment(user=self.user, topic=self.topic)
like_a = CommentLike.objects.create(user=self.user2, comment=comment_a)
like_b = CommentLike.objects.create(user=self.user2, comment=comment_b)
like_c = CommentLike.objects.create(user=self.user2, comment=comment_c)
CommentLike.objects.filter(pk=like_a.pk).update(
date=timezone.now() - datetime.timedelta(days=10))
CommentLike.objects.filter(pk=like_c.pk).update(
date=timezone.now() - datetime.timedelta(days=5))
utils.login(self)
response = self.client.get(
reverse("spirit:profile-likes",
kwargs={
'pk': self.user2.pk,
'slug': self.user2.slug
}))
self.assertQuerysetEqual(response.context['comments'],
map(repr, [comment_b, comment_c, comment_a]))
def test_topic_notification_list_show_private_topic(self):
"""
topic private in notification list
"""
TopicNotification.objects.all().delete()
topic_a = utils.create_private_topic(user=self.user)
topic_notif = TopicNotification.objects.create(user=self.user,
topic=topic_a.topic,
comment=self.comment,
is_active=True,
action=COMMENT)
utils.login(self)
response = self.client.get(reverse('spirit:topic-notification-list'))
self.assertQuerysetEqual(response.context['notifications'],
map(repr, [
topic_notif,
]))
# list unread should behave the same
response = self.client.get(
reverse('spirit:topic-notification-list-unread'))
self.assertQuerysetEqual(response.context['page'],
map(repr, [
topic_notif,
]))
# ajax list should behave the same
response = self.client.get(reverse('spirit:topic-notification-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
res = json.loads(response.content)
self.assertEqual(len(res['n']), 1)
def test_topic_notification_ajax_order(self):
"""
order by is_read=False first then by date
"""
user = utils.create_user()
for _ in xrange(10):
topic = utils.create_topic(self.category, user=user)
comment = utils.create_comment(topic=topic, user=user)
TopicNotification.objects.create(user=self.user,
topic=topic,
comment=comment,
is_active=True,
action=COMMENT)
TopicNotification.objects.filter(user=self.user).update(is_read=True)
old_date = timezone.now() - datetime.timedelta(days=10)
TopicNotification.objects.filter(pk=self.topic_notification.pk).update(
is_read=False, date=old_date)
utils.login(self)
response = self.client.get(reverse('spirit:topic-notification-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
res = json.loads(response.content)
self.assertFalse(res['n'][0]['is_read'])
self.assertTrue(res['n'][1]['is_read'])
def main():
parser = get_argparser()
args = parser.parse_args()
username = args.email
password = args.password
blacklist = ['junk', 'trash', 'drafts']
if args.ignore:
blacklist.extend([b.lower() for b in args.ignore])
if not os.path.isdir('backup'):
os.makedirs('backup')
browser = webdriver.Firefox()
try:
login(browser, username, password)
mailboxes = get_mailboxes(browser, blacklist)
print('The following folders will be backed up:')
for box in mailboxes:
print(box)
for box in mailboxes:
print('Backing %s up' % box)
fetch_emails(browser, box)
print('%s backup complete!' % box)
finally:
browser.close()
print('Backup complete!')
def test_comment_undelete(self):
"""
comment undelete
"""
self.user = utils.create_user(is_moderator=True)
comment = utils.create_comment(user=self.user,
topic=self.topic,
is_removed=True)
utils.login(self)
form_data = {}
response = self.client.post(
reverse('spirit:comment-undelete', kwargs={
'pk': comment.pk,
}), form_data)
expected_url = comment.get_absolute_url()
self.assertRedirects(response,
expected_url,
status_code=302,
target_status_code=302)
response = self.client.get(
reverse('spirit:comment-undelete', kwargs={
'pk': comment.pk,
}))
self.assertEqual(response.status_code, 200)
def test_resend_activation_email_redirect_logged(self):
"""
resend_activation_email redirect to profile if user is logged in
"""
utils.login(self)
response = self.client.get(reverse('spirit:resend-activation'))
expected_url = reverse("spirit:profile-update")
self.assertRedirects(response, expected_url, status_code=302)
def test_register_next_logged_in(self):
"""
redirect next on register
"""
# redirect logged in user
utils.login(self)
response = self.client.get(reverse('spirit:user-register') + "?next=/fakepath/")
self.assertRedirects(response, '/fakepath/', status_code=302, target_status_code=404)
def test_user_mods(self):
"""
List of admins
"""
mod = utils.create_user(is_moderator=True)
utils.login(self)
response = self.client.get(reverse('spirit:admin-user-mods'))
self.assertQuerysetEqual(response.context['users'], map(repr, [mod, ]))
def test_private_detail(self):
"""
private topic detail
"""
utils.login(self)
private = utils.create_private_topic(user=self.user)
response = self.client.get(reverse("spirit:private-detail", kwargs={"topic_id": private.topic.pk}))
self.assertEqual(response.context["topic"], private.topic)
def test_topic_pinned(self):
"""
Pinned topics
"""
topic_ = utils.create_topic(self.category, is_pinned=True)
utils.login(self)
response = self.client.get(reverse('spirit:admin-topic-pinned'))
self.assertQuerysetEqual(response.context['topics'], map(repr, [topic_, ]))
def setUp(self):
self.options = webdriver.ChromeOptions()
self.options.add_experimental_option("excludeSwitches", ["ignore-certificate-errors"])
self.driver = webdriver.Chrome(chrome_options=self.options)
self.driver.implicitly_wait(10)
self.base_url = "http://127.0.0.1:8000"
self.verificationErrors = []
self.accept_next_alert = True
utils.login(self.driver)
def test_favorite_create_next(self):
"""
create favorite using next
"""
utils.login(self)
form_data = {'next': '/fakepath/', }
response = self.client.post(reverse('spirit:favorite-create', kwargs={'topic_id': self.topic.pk, }),
form_data)
self.assertRedirects(response, '/fakepath/', status_code=302, target_status_code=404)
def test_user_unactive(self):
"""
List of unactive
"""
unactive = utils.create_user()
User.objects.filter(pk=unactive.pk).update(is_active=False)
utils.login(self)
response = self.client.get(reverse('spirit:admin-user-unactive'))
self.assertQuerysetEqual(response.context['users'], map(repr, [unactive, ]))
def test_private_detail(self):
"""
private topic detail
"""
utils.login(self)
private = utils.create_private_topic(user=self.user)
response = self.client.get(reverse('spirit:private-detail', kwargs={'topic_id': private.topic.pk,
'slug': private.topic.slug}))
self.assertEqual(response.context['topic'], private.topic)
def test_topic_detail_view(self):
"""
should display topic
"""
utils.login(self)
category = utils.create_category()
topic = utils.create_topic(category=category)
response = self.client.get(reverse('spirit:topic-detail', kwargs={'pk': topic.pk, }))
self.assertEqual(response.context['topic'], topic)
def test_category_list(self):
"""
Categories, excludes Topic Private and subcats
"""
subcat = utils.create_category(parent=self.category)
categories = Category.objects.filter(is_private=False, parent=None)
utils.login(self)
response = self.client.get(reverse('spirit:admin-category-list'))
self.assertQuerysetEqual(response.context['categories'], map(repr, categories))
def test_comment_publish_next(self):
"""
next on create comment
"""
utils.login(self)
form_data = {'comment': 'foobar', 'next': '/fakepath/'}
response = self.client.post(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk, }),
form_data)
self.assertRedirects(response, '/fakepath/', status_code=302, target_status_code=404)
def test_favorite_create(self):
"""
create favorite
"""
utils.login(self)
form_data = {}
response = self.client.post(reverse('spirit:favorite-create', kwargs={'topic_id': self.topic.pk, }),
form_data)
self.assertRedirects(response, self.topic.get_absolute_url(), status_code=302)
self.assertEqual(len(TopicFavorite.objects.all()), 1)
def test_like_delete_next(self):
"""
delete like using next
"""
utils.login(self)
like = CommentLike.objects.create(user=self.user, comment=self.comment)
form_data = {'next': '/fakepath/', }
response = self.client.post(reverse('spirit:like-delete', kwargs={'pk': like.pk, }),
form_data)
self.assertRedirects(response, '/fakepath/', status_code=302, target_status_code=404)
def test_bookmark_create(self):
"""
create comment
"""
utils.login(self)
form_data = {'comment_number': 999, }
response = self.client.post(reverse('spirit:bookmark-create', kwargs={'topic_id': self.topic.pk, }),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=form_data)
self.assertEqual(response.status_code, 200)
def test_profile_topics(self):
"""
profile user's topics
"""
utils.login(self)
response = self.client.get(reverse("spirit:profile-topics", kwargs={'pk': self.user2.pk,
'slug': self.user2.slug}))
self.assertEqual(response.status_code, 200)
self.assertQuerysetEqual(response.context['topics'], [repr(self.topic), ])
self.assertEqual(repr(response.context['p_user']), repr(self.user2))
def test_topic_detail_view_invalid_slug(self):
"""
invalid slug
"""
utils.login(self)
category = utils.create_category()
topic = utils.create_topic(category=category)
response = self.client.get(reverse('spirit:topic-detail', kwargs={'pk': topic.pk,
'slug': 'bar'}))
self.assertRedirects(response, topic.get_absolute_url(), status_code=301)
def test_profile_likes_invalid_slug(self):
"""
profile user's likes, invalid user slug
"""
utils.login(self)
response = self.client.get(reverse("spirit:profile-likes", kwargs={'pk': self.user2.pk,
'slug': "invalid"}))
expected_url = reverse("spirit:profile-likes", kwargs={'pk': self.user2.pk,
'slug': self.user2.slug})
self.assertRedirects(response, expected_url, status_code=301)
def test_advanced_search_topics(self):
"""
advanced search by topic
"""
utils.login(self)
data = {'q': 'spirit search', }
response = self.client.get(reverse('spirit:search'),
data)
self.assertEqual(response.status_code, 200)
self.assertQuerysetEqual([s.object for s in response.context['page']], map(repr, [self.topic, ]))
def test_comment_publish_quote(self):
"""
create comment quote
"""
utils.login(self)
comment = utils.create_comment(topic=self.topic)
response = self.client.get(reverse('spirit:comment-publish', kwargs={'topic_id': self.topic.pk,
'pk': comment.pk}))
self.assertEqual(response.context['form'].initial['comment'],
markdown.quotify(comment.comment, comment.user.username))