def test_stellar_badge1(self):
exercise = self.post_exercise(user = self.u1)
settings.update('STELLAR_EXERCISE_BADGE_MIN_STARS', 2)
self.u2.toggle_favorite_exercise(exercise)
self.assert_have_badge('stellar-exercise', self.u1, 0)
self.u3.toggle_favorite_exercise(exercise)
self.assert_have_badge('stellar-exercise', self.u1, 1)
def update_media_revision(skin = None):
"""update skin media revision number based on the contents
of the skin media directory"""
from askbot.conf import settings as askbot_settings
resource_revision = askbot_settings.MEDIA_RESOURCE_REVISION
if skin:
if skin in get_skin_choices():
skin_path = get_path_to_skin(skin)
else:
raise MediaNotFound('Skin %s not found' % skin)
else:
skin = 'default'
skin_path = get_path_to_skin(askbot_settings.ASKBOT_DEFAULT_SKIN)
media_dirs = [
os.path.join(skin_path, 'media'),
os.path.join(get_path_to_skin('common'), 'media')#we always use common
]
if skin != 'default':
#we have default skin as parent of the custom skin
default_skin_path = get_path_to_skin('default')
media_dirs.append(os.path.join(default_skin_path, 'media'))
current_hash = hasher.get_hash_of_dirs(media_dirs)
if current_hash != askbot_settings.MEDIA_RESOURCE_REVISION_HASH:
askbot_settings.update('MEDIA_RESOURCE_REVISION', resource_revision + 1)
askbot_settings.update('MEDIA_RESOURCE_REVISION_HASH', current_hash)
logging.debug('MEDIA_RESOURCE_REVISION changed')
askbot_settings.MEDIA_RESOURCE_REVISION
def test_associate_editor_badge(self):
self.u2.set_status('m')
question = self.post_question(user = self.u1)
settings.update('ASSOCIATE_EDITOR_BADGE_MIN_EDITS', 2)
self.u2.edit_question(
question = question,
title = 'hahaha',
body_text = 'sdgsdjghsldkfshd',
revision_comment = 'sdgdfgsgfs'
)
self.assert_have_badge('strunk-and-white', self.u2, 0)
self.u2.edit_question(
question = question,
title = 'hahaha',
body_text = 'sdgsdjghsldkfshd',
revision_comment = 'sdgdfgsgfs'
)
self.assert_have_badge('strunk-and-white', self.u2, 1)
self.u2.edit_question(
question = question,
title = 'hahaha',
body_text = 'sdgsdjghsldkfshd',
revision_comment = 'sdgdfgsgfs'
)
self.assert_have_badge('strunk-and-white', self.u2, 1)
def setUp(self):
# An administrator user
self.owner = User.objects.create_user(username='******', email='*****@*****.**', password='******')
self.owner.is_staff = True
self.owner.is_superuser = True
self.owner.save()
# A moderator
self.mod1 = create_user(username='******', email='*****@*****.**', status='m')
self.mod1.set_password('modpw')
self.mod1.save()
# A normal user
User.objects.create_user(username='******', email='*****@*****.**', password='******')
# Setup a small category tree
self.root = Category.objects.create(name=u'Root')
self.c1 = Category.objects.create(name=u'Child1', parent=self.root)
self.c2 = Category.objects.create(name=u'Child2', parent=self.c1)
c3 = Category.objects.create(name=u'Child3', parent=self.root)
self.tag1 = Tag.objects.create(name=u'Tag1', created_by=self.owner)
self.tag2 = Tag.objects.create(name=u'Tag2', created_by=self.owner)
self.tag2.categories.add(self.c1)
self.tag3 = Tag.objects.create(name=u'Tag3', created_by=self.owner)
self.tag3.categories.add(c3)
askbot_settings.update('ENABLE_CATEGORIES', True)
askbot_settings.update('CATEGORIES_MAX_TREE_DEPTH', 3)
def setup_data(self, is_anon, can_be_anon, is_owner, box_checked):
"""sets up data in the same order as shown in the
truth table above
the four positional arguments are in the same order
"""
askbot_settings.update('ALLOW_ASK_ANONYMOUSLY', can_be_anon)
question = self.post_question(is_anonymous = is_anon)
if is_owner:
editor = self.user
else:
editor = self.other_user
data = {
'tags': 'tag1 tag2',
'text': 'ostaousohuosuh',
'title': 'stahosetuhaoeudhuh'
}
if box_checked:
data['reveal_identity'] = 'on'
self.form = forms.EditQuestionForm(
data,
question=question,
user=editor,
revision=question.get_latest_revision(),
)
def forwards(self, orm):
"""reads category tree saved as string,
translates it to json and saves back"""
old_data = askbot_settings.CATEGORY_TREE
json_data = parse_tree(old_data)
json_string = simplejson.dumps(json_data)
askbot_settings.update('CATEGORY_TREE', json_string)
def test_get_moderators_with_groups(self):
groups_enabled_backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update("GROUPS_ENABLED", True)
# create group
group = Group(name="testers", openness=Group.OPEN)
group.save()
# create one admin and one moderator, and one reg user
mod1 = self.create_user("mod1", status="m")
adm1 = self.create_user("adm1", status="d")
reg1 = self.create_user("reg1")
# join them to the group
mod1.join_group(group)
adm1.join_group(group)
reg1.join_group(group)
# create one admin and one moderator, and one reg user
mod2 = self.create_user("mod2", status="m")
adm2 = self.create_user("adm2", status="d")
reg2 = self.create_user("reg2")
# make a post
question = self.post_question(user=reg1, group_id=group.id)
# run get_moderators and see that only one admin and one
mods = question.get_moderators()
self.assertEqual(set([mod1, adm1]), set(mods))
# moderator are in the set of moderators
askbot_settings.update("GROUPS_ENABLED", groups_enabled_backup)
def test_stellar_badge1(self):
question = self.post_question(user = self.u1)
settings.update('STELLAR_QUESTION_BADGE_MIN_STARS', 2)
self.u2.toggle_favorite_question(question)
self.assert_have_badge('stellar-question', self.u1, 0)
self.u3.toggle_favorite_question(question)
self.assert_have_badge('stellar-question', self.u1, 1)
def test_get_moderators_with_groups(self):
groups_enabled_backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update('GROUPS_ENABLED', True)
#create group
group = Group(name='testers', openness=Group.OPEN)
group.save()
#create one admin and one moderator, and one reg user
mod1 = self.create_user('mod1', status='m')
adm1 = self.create_user('adm1', status='d')
reg1 = self.create_user('reg1')
#join them to the group
mod1.join_group(group)
adm1.join_group(group)
reg1.join_group(group)
#create one admin and one moderator, and one reg user
mod2 = self.create_user('mod2', status='m')
adm2 = self.create_user('adm2', status='d')
reg2 = self.create_user('reg2')
#make a post
exercise = self.post_exercise(user=reg1, group_id=group.id)
#run get_moderators and see that only one admin and one
mods = exercise.get_moderators()
self.assertEqual(
set([mod1, adm1]),
set(mods)
)
#moderator are in the set of moderators
askbot_settings.update('GROUPS_ENABLED', groups_enabled_backup)
def __init__(self, *args, **kwargs):
super(Command, self).__init__(*args, **kwargs)
#relax certain settings
askbot_settings.update('LIMIT_ONE_ANSWER_PER_USER', False)
askbot_settings.update('MAX_COMMENT_LENGTH', 1000000)
#askbot_settings.update('MIN_REP_TO_LEAVE_COMMENTS', 1)
self.bad_email_count = 0
def update_media_revision(skin=None):
"""update skin media revision number based on the contents
of the skin media directory"""
from askbot.conf import settings as askbot_settings
resource_revision = askbot_settings.MEDIA_RESOURCE_REVISION
skin = skin or askbot_settings.ASKBOT_DEFAULT_SKIN
if skin in get_available_skins().keys():
skin_path = get_path_to_skin(skin)
else:
assert(skin != 'default')
msg = 'Skin "%s" not found. Please check ASKBOT_EXTRA_SKINS_DIR setting'
raise MediaNotFound(msg % skin)
media_dirs = [
os.path.join(skin_path, 'media'),
]
if skin != 'default':
#we have default skin as parent of the custom skin
default_skin_path = get_path_to_skin('default')
media_dirs.append(os.path.join(default_skin_path, 'media'))
current_hash = hasher.get_hash_of_dirs(media_dirs)
if current_hash != askbot_settings.MEDIA_RESOURCE_REVISION_HASH:
askbot_settings.update('MEDIA_RESOURCE_REVISION', resource_revision + 1)
askbot_settings.update('MEDIA_RESOURCE_REVISION_HASH', current_hash)
logging.debug('MEDIA_RESOURCE_REVISION changed')
def test_catch_missing_mandatory_tag(self):
askbot_settings.update('MANDATORY_TAGS', 'one two')
self.assertRaises(
django_forms.ValidationError,
self.clean,
('three',)
)
def test_categories_off(self):
"""AJAX category-related views shouldn't be published when master switch is off."""
askbot_settings.update('ENABLE_CATEGORIES', False)
r = self.ajax_post_json(reverse('add_category'), {'name': u'Entertainment', 'parent': self.root.id})
self.assertEqual(r.status_code, 404)
askbot_settings.update('ENABLE_CATEGORIES', True)
r = self.ajax_post_json(reverse('add_category'), {'name': u'Family', 'parent': self.root.id})
self.assertEqual(r.status_code, 200)
def setUp(self):
self._backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update("GROUPS_ENABLED", True)
self.user = self.create_user("user")
group = models.Group.objects.create(name="the group", openness=models.Group.OPEN)
self.user.join_group(group)
self.question = self.post_question(user=self.user)
self.client.login(user_id=self.user.id, method="force")
def setUp(self):
self._backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update("GROUPS_ENABLED", True)
self.user = self.create_user("user")
self.group = models.Group.objects.create(name="the group", openness=models.Group.OPEN)
self.user.join_group(self.group)
self.qdata = {"title": "test question title", "text": "test question text"}
self.client.login(user_id=self.user.id, method="force")
def test_custom_case(self):
"""FORCE_LOWERCASE setting is off
"""
askbot_settings.update('FORCE_LOWERCASE_TAGS', False)
models.Tag(name = 'TAG1', created_by = self.user).save()
models.Tag(name = 'Tag2', created_by = self.user).save()
cleaned_tags = self.clean('tag1 taG2 TAG1 tag3 tag3')
self.assert_tags_equal(cleaned_tags, ['TAG1', 'Tag2', 'tag3'])
def tearDown(self):
#delete the dummy skin
test_skin_dir = os.path.join(
self.temp_dir,
'test_skin'
)
shutil.rmtree(self.temp_dir)
askbot_settings.update('ASKBOT_DEFAULT_SKIN', 'default')
django_settings.ASKBOT_EXTRA_SKINS_DIR = self.skins_dir_backup
def test_unlocalized_setting(self):
backup = askbot_settings.MIN_REP_TO_VOTE_UP
askbot_settings.update('MIN_REP_TO_VOTE_UP', 500)
self.assertSettingEquals('MIN_REP_TO_VOTE_UP', 500)
translation.activate('de')
self.assertSettingEquals('MIN_REP_TO_VOTE_UP', 500)
askbot_settings.update('MIN_REP_TO_VOTE_UP', backup)
def test_uploaded_logo(self):
logo_src = os.path.join(askbot.get_install_directory(), "tests", "images", "logo.gif")
logo_file = open(logo_src, "r")
new_logo = UploadedFile(file=logo_file)
askbot_settings.update("SITE_LOGO_URL", new_logo)
logo_url = askbot_settings.SITE_LOGO_URL
self.assertTrue(logo_url.startswith(django_settings.MEDIA_URL))
response = self.client.get(logo_url)
self.assertTrue(response.status_code == 200)
def test_user_dislikes_wildcard(self):
"""user set must have one user who does not dislike the tag via wildcard"""
self.set_email_tag_filter_strategy(const.EXCLUDE_IGNORED)
askbot_settings.update('USE_WILDCARD_TAGS', True)
self.u1.mark_tags(wildcards = ('da*',), reason = 'I', action = 'add')
self.assert_subscribers_are(
expected_subscribers = set([self.u2,]),
reason = 'I'
)
def test_user_likes_wildcard(self):
"""user set must contain one person who likes the tag via wildcard"""
self.set_email_tag_filter_strategy(const.INCLUDE_INTERESTING)
askbot_settings.update('USE_WILDCARD_TAGS', True)
self.u1.mark_tags(wildcards = ('da*',), reason = 'S', action = 'add')
self.assert_subscribers_are(
expected_subscribers = set([self.u1,]),
reason = 'S'
)
def test_user_does_not_care_about_question_no_wildcards(self):
askbot_settings.update('USE_WILDCARD_TAGS', False)
tag = models.Tag(name='five', created_by=self.user)
tag.save()
mt = models.MarkedTag(user=self.user, tag=tag, reason='good')
mt.save()
self.assertFalse(
self.user.has_affinity_to_question(question=self.question,
affinity_type='like'))
def setup_wildcard(self, wildcard=None, reason=None):
if reason == 'good':
self.user.interesting_tags = wildcard
self.user.ignored_tags = ''
else:
self.user.ignored_tags = wildcard
self.user.interesting_tags = ''
self.user.save()
askbot_settings.update('USE_WILDCARD_TAGS', True)
def test_no_category_simple_success(self):
"""Tags page should work without errors when no category is specified"""
r = self.client.get('/%s' % _('tags/'))
self.assertEqual(200, r.status_code)
# Same thing when master categories switch is off
askbot_settings.update('ENABLE_CATEGORIES', False)
r = self.client.get('/%s' % _('tags/'))
self.assertEqual(200, r.status_code)
def tearDown(self):
#delete the dummy skin
test_skin_dir = os.path.join(self.temp_dir, 'test_skin')
shutil.rmtree(self.temp_dir)
askbot_settings.update('ASKBOT_DEFAULT_SKIN', 'default')
if self.skins_dir_backup is None:
del (django_settings.ASKBOT_EXTRA_SKINS_DIR)
else:
django_settings.ASKBOT_EXTRA_SKINS_DIR = self.skins_dir_backup
def test_global_group_name_setting_changes_group_name(self):
orig_group_name = askbot_settings.GLOBAL_GROUP_NAME;
askbot_settings.update('GLOBAL_GROUP_NAME', 'all-people')
group = models.Group.objects.get_global_group()
self.assertEqual(group.name, 'all-people')
# Revert the global group name, so we don't mess up other tests!
askbot_settings.update('GLOBAL_GROUP_NAME', orig_group_name);
group = models.Group.objects.get_global_group()
self.assertEqual(group.name, orig_group_name)
def proto_test_ask_page(self, allow_anonymous, status_code):
prev_setting = askbot_settings.ALLOW_POSTING_BEFORE_LOGGING_IN
askbot_settings.update('ALLOW_POSTING_BEFORE_LOGGING_IN', allow_anonymous)
self.try_url(
'ask',
status_code = status_code,
template = 'ask.html'
)
askbot_settings.update('ALLOW_POSTING_BEFORE_LOGGING_IN', prev_setting)
def tearDown(self):
#delete the dummy skin
test_skin_dir = os.path.join(
askbot.get_install_directory(),
'skins',
'test_skin'
)
shutil.rmtree(test_skin_dir)
askbot_settings.update('ASKBOT_DEFAULT_SKIN', 'default')
def setup_wildcard(self, wildcard = None, reason = None):
if reason == 'good':
self.user.interesting_tags = wildcard
self.user.ignored_tags = ''
else:
self.user.ignored_tags = wildcard
self.user.interesting_tags = ''
self.user.save()
askbot_settings.update('USE_WILDCARD_TAGS', True)
def test_global_group_name_setting_changes_group_name(self):
orig_group_name = askbot_settings.GLOBAL_GROUP_NAME
askbot_settings.update('GLOBAL_GROUP_NAME', 'all-people')
group = models.Group.objects.get_global_group()
self.assertEqual(group.name, 'all-people')
# Revert the global group name, so we don't mess up other tests!
askbot_settings.update('GLOBAL_GROUP_NAME', orig_group_name)
group = models.Group.objects.get_global_group()
self.assertEqual(group.name, orig_group_name)
def proto_test_ask_page(self, allow_anonymous, status_code):
prev_setting = askbot_settings.ALLOW_POSTING_BEFORE_LOGGING_IN
askbot_settings.update('ALLOW_POSTING_BEFORE_LOGGING_IN', allow_anonymous)
self.try_url(
'ask',
status_code = status_code,
template = 'ask.html'
)
askbot_settings.update('ALLOW_POSTING_BEFORE_LOGGING_IN', prev_setting)
def test_uploaded_logo(self):
logo_src = os.path.join(askbot.get_install_directory(), 'tests',
'images', 'logo.gif')
logo_file = open(logo_src, 'r')
new_logo = UploadedFile(file=logo_file)
askbot_settings.update('SITE_LOGO_URL', new_logo)
logo_url = askbot_settings.SITE_LOGO_URL
self.assertTrue(logo_url.startswith(django_settings.MEDIA_URL))
response = self.client.get(logo_url)
self.assertTrue(response.status_code == 200)
def test_user_likes_wildcard(self):
"""user set must contain one person who likes the tag via wildcard"""
self.set_email_tag_filter_strategy(const.INCLUDE_INTERESTING)
askbot_settings.update('USE_WILDCARD_TAGS', True)
self.u1.mark_tags(wildcards = ('da*',), reason = 'good', action = 'add')
self.u1.save()
self.assert_subscribers_are(
expected_subscribers = set([self.u1,]),
reason = 'good'
)
def test_user_dislikes_wildcard(self):
"""user set must have one user who does not dislike the tag via wildcard"""
self.set_email_tag_filter_strategy(const.EXCLUDE_IGNORED)
askbot_settings.update('USE_WILDCARD_TAGS', True)
self.u1.mark_tags(wildcards = ('da*',), reason = 'bad', action = 'add')
self.u1.save()
self.assert_subscribers_are(
expected_subscribers = set([self.u2,]),
reason = 'bad'
)
def setUp(self):
self._backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update('GROUPS_ENABLED', True)
self.user = self.create_user('user')
group = models.Group.objects.create(
name='the group', openness=models.Group.OPEN
)
self.user.join_group(group)
self.question = self.post_question(user=self.user)
self.client.login(user_id=self.user.id, method='force')
def test_reminder_simple(self):
"""a positive test - user must receive a reminder
"""
askbot_settings.update("ENABLE_UNANSWERED_REMINDERS", True)
days_ago = 5 * askbot_settings.DAYS_BEFORE_SENDING_UNANSWERED_REMINDER
long_ago = datetime.datetime.now() - datetime.timedelta(days_ago)
self.post_question(user=self.u1, timestamp=long_ago)
management.call_command("send_unanswered_question_reminders")
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
def setup_data(self, allow_anonymous = True, ask_anonymously = None):
askbot_settings.update('ALLOW_ASK_ANONYMOUSLY', allow_anonymous)
data = {
'title': 'test title',
'text': 'test content',
'tags': 'test',
}
if ask_anonymously == True:
data['ask_anonymously'] = 'on'
self.form = forms.AskForm(data, user=AnonymousUser())
self.form.full_clean()
def toggle_user_answer_limit_setting(val):
"""Turns the Askbot live_setting for LIMIT_ONE_ANSWER_PER_USER on
or off.
:param val: (bool) value to set LIMIT_ONE_ANSWER_PER_USER to
"""
if val:
askbot_settings.update('LIMIT_ONE_ANSWER_PER_USER', True)
else:
askbot_settings.update('LIMIT_ONE_ANSWER_PER_USER', False)
print "set LIMIT_ONE_ANSWER_PER_USER to %s" % val
def setup_data(self, allow_anonymous=True, ask_anonymously=None):
askbot_settings.update('ALLOW_ASK_ANONYMOUSLY', allow_anonymous)
data = {
'title': 'test title',
'text': 'test content',
'tags': 'test',
}
if ask_anonymously:
data['ask_anonymously'] = 'on'
self.form = forms.AskForm(data, user=AnonymousUser())
self.form.full_clean()
def remove_email_from_invited_moderators(email):
"""Update the `INVITED_MODERATORS` setting by removing
the matching email entry"""
lines = askbot_settings.INVITED_MODERATORS.strip().split('\n')
clean_lines = list()
prefix = email + ' '
for line in lines:
if not line.startswith(prefix):
clean_lines.append(line)
if len(clean_lines) != len(lines):
value = '\n'.join(clean_lines)
askbot_settings.update('INVITED_MODERATORS', value)
def setUp(self):
self._backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update('GROUPS_ENABLED', True)
self.user = self.create_user('user')
self.group = models.Group.objects.create(name='the group',
openness=models.Group.OPEN)
self.user.join_group(self.group)
self.qdata = {
'title': 'test question title',
'text': 'test question text'
}
self.client.login(user_id=self.user.id, method='force')
def test_user_does_not_care_about_question_no_wildcards(self):
askbot_settings.update('USE_WILDCARD_TAGS', False)
tag = models.Tag(name = 'five', created_by = self.user)
tag.save()
mt = models.MarkedTag(user = self.user, tag = tag, reason = 'good')
mt.save()
self.assertFalse(
self.user.has_affinity_to_question(
question = self.question,
affinity_type = 'like'
)
)
def test_civic_duty_badge(self):
settings.update('CIVIC_DUTY_BADGE_MIN_VOTES', 2)
question = self.post_question(user = self.u1)
answer = self.post_answer(user = self.u2, question = question)
answer2 = self.post_answer(user = self.u1, question = question)
self.u3.upvote(question)
self.u3.downvote(answer)
self.assert_have_badge('civic-duty', recipient = self.u3)
self.u3.upvote(answer2)
self.assert_have_badge('civic-duty', recipient = self.u3, expected_count = 1)
self.u3.downvote(answer)
self.assert_have_badge('civic-duty', recipient = self.u3, expected_count = 1)
def forwards(self, orm):
"""reads category tree saved as string,
translates it to json and saves back"""
old_data = askbot_settings.CATEGORY_TREE
#this special value is our new default,
#we don't want to create a tag with this name
if old_data.replace(' ', '') == '[["dummy",[]]]':
old_data = ''
json_data = parse_tree(old_data)
json_string = simplejson.dumps(json_data)
askbot_settings.update('CATEGORY_TREE', json_string)
def test_user_dislikes_wildcard_and_matching_tag(self):
"""user ignores tag "day" and ignores a wildcard "da*"
"""
self.set_email_tag_filter_strategy(const.EXCLUDE_IGNORED)
askbot_settings.update('USE_WILDCARD_TAGS', True)
self.u1.mark_tags(tagnames=('day', ),
wildcards=('da*', ),
reason='bad',
action='add')
self.assert_subscribers_are(expected_subscribers=set([
self.u2,
]),
reason='bad')
def test_reminder_simple(self):
"""a positive test - user must receive a reminder
"""
askbot_settings.update('ENABLE_UNANSWERED_REMINDERS', True)
days_ago = 5*askbot_settings.DAYS_BEFORE_SENDING_UNANSWERED_REMINDER
long_ago = datetime.datetime.now() - datetime.timedelta(days_ago)
self.post_question(
user = self.u1,
timestamp = long_ago
)
management.call_command('send_unanswered_question_reminders')
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
def test_stellar_badge3(self):
question = self.post_question(user=self.u1)
settings.update('STELLAR_QUESTION_BADGE_MIN_STARS', 2)
self.u2.toggle_favorite_question(question)
self.assert_have_badge('stellar-question', self.u1, 0)
self.u3.toggle_favorite_question(question)
#award now
self.assert_have_badge('stellar-question', self.u1, 1)
self.u3.toggle_favorite_question(question)
#dont take back
self.assert_have_badge('stellar-question', self.u1, 1)
self.u3.toggle_favorite_question(question)
#dont reaward
self.assert_have_badge('stellar-question', self.u1, 1)
def wrapped(*args, **kwargs):
from askbot.conf import settings as askbot_settings
backup_settings_dict = dict()
for key, value in settings_dict.items():
backup_settings_dict[key] = getattr(askbot_settings, key)
askbot_settings.update(key, value)
try:
return func(*args, **kwargs)
except:
raise
finally:
for key, value in backup_settings_dict.items():
askbot_settings.update(key, value)
def test_stellar_badge3(self):
exercise = self.post_exercise(user=self.u1)
settings.update('STELLAR_EXERCISE_BADGE_MIN_STARS', 2)
self.u2.toggle_favorite_exercise(exercise)
self.assert_have_badge('stellar-exercise', self.u1, 0)
self.u3.toggle_favorite_exercise(exercise)
#award now
self.assert_have_badge('stellar-exercise', self.u1, 1)
self.u3.toggle_favorite_exercise(exercise)
#dont take back
self.assert_have_badge('stellar-exercise', self.u1, 1)
self.u3.toggle_favorite_exercise(exercise)
#dont reaward
self.assert_have_badge('stellar-exercise', self.u1, 1)
def test_categories_off(self):
"""AJAX category-related views shouldn't be published when master switch is off."""
askbot_settings.update('ENABLE_CATEGORIES', False)
r = self.ajax_post_json(reverse('add_category'), {
'name': u'Entertainment',
'parent': self.root.id
})
self.assertEqual(r.status_code, 404)
askbot_settings.update('ENABLE_CATEGORIES', True)
r = self.ajax_post_json(reverse('add_category'), {
'name': u'Family',
'parent': self.root.id
})
self.assertEqual(r.status_code, 200)
def test_localized_setting(self):
translation.activate('de')
askbot_settings.as_dict() #hit settings in German
backup = askbot_settings.WORDS_ASK_YOUR_QUESTION
translation.activate('en')
askbot_settings.update('WORDS_ASK_YOUR_QUESTION', 'Stelle deine frage',
'de')
self.assertSettingEquals('WORDS_ASK_YOUR_QUESTION',
'Ask Your Question')
translation.activate('de')
self.assertSettingEquals('WORDS_ASK_YOUR_QUESTION',
'Stelle deine frage')
askbot_settings.update('WORDS_ASK_YOUR_QUESTION', backup, 'de')
def setUp(self):
self.groups_enabled_backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update('GROUPS_ENABLED', True)
self.admin = self.create_user('admin', status='d')
self.user = self.create_user('user',
notification_schedule={
'q_ask': 'i',
'q_all': 'i',
'q_ans': 'i',
'q_sel': 'i',
'm_and_c': 'i'
})
self.group = models.Group.objects.get_or_create(name='jockeys')
self.admin.edit_group_membership(group=self.group,
user=self.admin,
action='add')
def test_subject_line(self):
"""loops through various forms of the subject line
and makes sure that tags and title are parsed out"""
setting_backup = askbot_settings.TAGS_ARE_REQUIRED
askbot_settings.update('TAGS_ARE_REQUIRED', True)
for test_case in SUBJECT_LINE_CASES:
self.data['subject'] = test_case[0]
form = forms.AskByEmailForm(self.data)
output = test_case[1]
if output is None:
self.assertFalse(form.is_valid())
else:
self.assertTrue(form.is_valid())
self.assertEquals(form.cleaned_data['tagnames'], output[0])
self.assertEquals(form.cleaned_data['title'], output[1])
askbot_settings.update('TAGS_ARE_REQUIRED', setting_backup)
def test_civic_duty_badge(self):
settings.update('CIVIC_DUTY_BADGE_MIN_VOTES', 2)
exercise = self.post_exercise(user=self.u1)
problem = self.post_problem(user=self.u2, exercise=exercise)
problem2 = self.post_problem(user=self.u1, exercise=exercise)
self.u3.upvote(exercise)
self.u3.downvote(problem)
self.assert_have_badge('civic-duty', recipient=self.u3)
self.u3.upvote(problem2)
self.assert_have_badge('civic-duty',
recipient=self.u3,
expected_count=1)
self.u3.downvote(problem)
self.assert_have_badge('civic-duty',
recipient=self.u3,
expected_count=1)
def test_wildcard_catches_new_tag(self):
"""users asks a question with a brand new tag
and other user subscribes to it by wildcard
"""
askbot_settings.update('USE_WILDCARD_TAGS', True)
self.user1.email_tag_filter_strategy = const.INCLUDE_INTERESTING
self.user1.save()
self.user1.mark_tags(wildcards=('some*', ),
reason='good',
action='add')
self.user2.post_question(title='some title',
body_text='some text for the question',
tags='something')
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
self.assertEqual(len(outbox[0].recipients()), 1)
self.assertTrue(self.user1.email in outbox[0].recipients())
def setUp(self):
self.u1 = self.create_user(username='******')
self.u2 = self.create_user(username='******')
askbot_settings.update('ENABLE_UNANSWERED_REMINDERS', True)
askbot_settings.update('MAX_UNANSWERED_REMINDERS', 5)
askbot_settings.update('UNANSWERED_REMINDER_FREQUENCY', 1)
askbot_settings.update('DAYS_BEFORE_SENDING_UNANSWERED_REMINDER', 2)
self.wait_days = askbot_settings.DAYS_BEFORE_SENDING_UNANSWERED_REMINDER
self.recurrence_days = askbot_settings.UNANSWERED_REMINDER_FREQUENCY
self.max_emails = askbot_settings.MAX_UNANSWERED_REMINDERS
def setUp(self):
self.u1 = self.create_user(username = '******')
self.u2 = self.create_user(username = '******')
askbot_settings.update(self.enable_setting_name, True)
askbot_settings.update(self.max_reminder_setting_name, 5)
askbot_settings.update(self.frequency_setting_name, 1)
askbot_settings.update(self.days_before_setting_name, 2)
self.wait_days = getattr(askbot_settings, self.days_before_setting_name)
self.recurrence_days = getattr(askbot_settings, self.frequency_setting_name)
self.max_emails = getattr(askbot_settings, self.max_reminder_setting_name)
def test_associate_editor_badge(self):
self.u2.set_status('m')
question = self.post_question(user=self.u1)
settings.update('ASSOCIATE_EDITOR_BADGE_MIN_EDITS', 2)
self.u2.edit_question(question=question,
title='hahaha',
body_text='sdgsdjghsldkfshd',
revision_comment='sdgdfgsgfs')
self.assert_have_badge('strunk-and-white', self.u2, 0)
self.u2.edit_question(question=question,
title='hahaha',
body_text='sdgsdjghsldkfshd',
revision_comment='sdgdfgsgfs')
self.assert_have_badge('strunk-and-white', self.u2, 1)
self.u2.edit_question(question=question,
title='hahaha',
body_text='sdgsdjghsldkfshd',
revision_comment='sdgdfgsgfs')
self.assert_have_badge('strunk-and-white', self.u2, 1)
def tearDown(self):
askbot_settings.update(
'REPLY_BY_EMAIL', self.reply_by_email
)
askbot_settings.update(
'CONTENT_MODERATION_MODE',
self.content_moderation_mode
)
askbot_settings.update(
'SELF_NOTIFY_EMAILED_POST_AUTHOR_WHEN',
self.self_notify_when
)
