def test_add_tags_new_taggeditem(self):
"""
add_tags function should only create a Tag if it doesn't already exist
"""
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
# test existing tag with different taggeditem
orange = food_model.objects.create(name="orange")
add_tags(orange, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(orange.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='food'),
[('apple','green'),('orange','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category1),
[('apple','green'),('orange','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user1),
[('apple','green'),('orange','green')])
def test_multiple_tags_multiple_users(self):
user1 = UserF(username="******")
person1 = Person(user=user1)
person1.save()
user2 = UserF(username="******")
person2 = Person(user=user2)
person2.save()
user3 = UserF(username="******")
person3 = Person(user=user3)
person3.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
tags = []
tagged_item = add_tags(person1, 'TagA',
'staff-directory-test-category', user1, 'person')
tagged_item = add_tags(person2, 'TagA',
'staff-directory-test-category', user1, 'person')
tags.append(tagged_item.tag.slug)
tagged_item = add_tags(person2, 'TagB',
'staff-directory-test-category', user1, 'person')
tagged_item = add_tags(person3, 'TagB',
'staff-directory-test-category', user2, 'person')
tags.append(tagged_item.tag.slug)
emails = _get_emails_for_tag(tags)
self.assertTrue(len(emails) == 1)
self.assertIn(user2.email, emails)
def test_single_tag_multiple_users(self):
user1 = UserF(username="******")
person1 = Person(user=user1)
person1.save()
user2 = UserF(username="******")
person2 = Person(user=user2)
person2.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
tags = []
tagged_item = add_tags(person1, 'TagA',
'staff-directory-test-category', user1,
'person')
tagged_item = add_tags(person2, 'TagA',
'staff-directory-test-category', user1,
'person')
tags.append(tagged_item.tag.slug)
emails = _get_emails_for_tag(tags)
self.assertTrue(len(emails) == 2)
self.assertIn(user1.email, emails)
self.assertIn(user2.email, emails)
def test_add_tags_new_taggeditem(self):
"""
add_tags function should only create a Tag if it doesn't already exist
"""
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
# test existing tag with different taggeditem
orange = food_model.objects.create(name="orange")
add_tags(orange, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(orange.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='food'),
[('apple', 'green'), ('orange', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category1),
[('apple', 'green'), ('orange', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user1),
[('apple', 'green'), ('orange', 'green')])
def detail(request, idea_id):
"""
Detail view; idea_id must be a string containing an int.
"""
idea = get_object_or_404(Idea, pk=int(idea_id))
if request.method == 'POST':
tag_form = IdeaTagForm(request.POST)
if tag_form.is_valid():
data = tag_form.clean()['tags']
tags = [tag.strip() for tag in data.split(',')
if tag.strip() != '']
try:
for t in tags:
add_tags(idea, t, None, request.user, 'idea')
except NameError: # catch if add_tags doesn't exist
idea.tags.add(*tags)
return HttpResponseRedirect(
reverse('idea:idea_detail', args=(idea.id,)))
else:
tag_form = IdeaTagForm()
voters = idea.voters.all()
for v in voters:
try:
v.profile = v.get_profile()
except (ObjectDoesNotExist, SiteProfileNotAvailable):
v.profile = None
idea_type = ContentType.objects.get(app_label="idea", model="idea")
tags = idea.tags.extra(select={
'tag_count': """
SELECT COUNT(*) from taggit_taggeditem tt
WHERE tt.tag_id = taggit_tag.id
AND content_type_id = %s
"""
}, select_params=[idea_type.id]).order_by('name')
tags_created_by_user = []
if COLLAB_TAGS:
for tag in tags:
tag.tag_url = "%s?tags=%s" % (reverse('idea:idea_list'), tag.slug)
for ti in tag.taggit_taggeditem_items.filter(tag_creator=request.user,
content_type__name="idea",
object_id=idea_id):
tags_created_by_user.append(tag.name)
return _render(request, 'idea/detail.html', {
'idea': idea, # title, body, user name, user photo, time
'support': request.user in voters,
'tags': tags,
'tags_created_by_user': tags_created_by_user,
'voters': voters,
'tag_form': tag_form
})
def detail(request, idea_id):
"""
Detail view; idea_id must be a string containing an int.
"""
idea = get_object_or_404(Idea, pk=int(idea_id))
if request.method == 'POST':
tag_form = IdeaTagForm(request.POST)
if tag_form.is_valid():
data = tag_form.clean()['tags']
tags = [tag.strip() for tag in data.split(',')
if tag.strip() != '']
try:
for t in tags:
add_tags(idea, t, None, request.user, 'idea')
except NameError: # catch if add_tags doesn't exist
idea.tags.add(*tags)
return HttpResponseRedirect(
reverse('idea:idea_detail', args=(idea.id,)))
else:
tag_form = IdeaTagForm()
voters = idea.voters.all()
for v in voters:
try:
v.profile = v.get_profile()
except (ObjectDoesNotExist, SiteProfileNotAvailable):
v.profile = None
idea_type = ContentType.objects.get(app_label="idea", model="idea")
tags = idea.tags.extra(select={
'tag_count': """
SELECT COUNT(*) from taggit_taggeditem tt
WHERE tt.tag_id = taggit_tag.id
AND content_type_id = %s
"""
}, select_params=[idea_type.id]).order_by('name')
tags_created_by_user = []
if COLLAB_TAGS:
for tag in tags:
tag.tag_url = "%s?tags=%s" % (reverse('idea:idea_list'), tag.slug)
for ti in tag.taggit_taggeditem_items.filter(tag_creator=request.user,
content_type__name="idea",
object_id=idea_id):
tags_created_by_user.append(tag.name)
return _render(request, 'idea/detail.html', {
'idea': idea, # title, body, user name, user photo, time
'support': request.user in voters,
'tags': tags,
'tags_created_by_user': tags_created_by_user,
'voters': voters,
'tag_form': tag_form
})
def save(self):
instance = super(IdeaForm, self).save(commit=False)
# add tags separately
tags = self.cleaned_data.get('tags', [])
self.cleaned_data['tags'] = []
instance.save()
try:
for t in tags:
add_tags(instance, t, None, instance.creator, 'idea')
except NameError: # catch if add_tags doesn't exist
instance.tags.add(*tags)
return instance
def save(self):
instance = super(IdeaForm, self).save(commit=False)
# add tags separately
tags = self.cleaned_data.get('tags', [])
self.cleaned_data['tags'] = []
instance.save()
try:
for t in tags:
add_tags(instance, t, None, instance.creator, 'idea')
except NameError: # catch if add_tags doesn't exist
instance.tags.add(*tags)
return instance
def test_tag_remove_exists_for_creator(self):
"""
Detail page allows for removal of tags created by the current user
"""
user1 = login(self)
idea = models.Idea(creator=user1, title='AAAA',
state = models.State.objects.get(name='Active'))
idea.save()
add_tags(idea, 'AAA', None, user1, 'idea')
response = self.client.get(reverse("idea:idea_detail", args=(str(idea.id),)))
self.assertContains(response, 'aaa')
self.assertContains(response, 'tag_remove')
def test_tag_remove_not_exists_for_random_user(self):
"""
Detail page does not allow for removal of tags created by a different user
"""
self.client.login(username='******', password='******')
user1 = random_user()
idea = models.Idea(creator=user1, title='AAAA',
state = models.State.objects.get(name='Active'))
idea.save()
add_tags(idea, 'AAA', None, user1, 'idea')
response = self.client.get(reverse("idea:idea_detail", args=(str(idea.id),)))
self.assertContains(response, 'aaa')
self.assertNotContains(response, 'tag_remove')
def test_tag_remove_exists_for_creator(self):
"""
Detail page allows for removal of tags created by the current user
"""
user1 = login(self)
idea = models.Idea(creator=user1,
title='AAAA',
state=models.State.objects.get(name='Active'))
idea.save()
add_tags(idea, 'AAA', None, user1, 'idea')
response = self.client.get(
reverse("idea:idea_detail", args=(str(idea.id), )))
self.assertContains(response, 'aaa')
self.assertContains(response, 'tag_remove')
def add_tag(req,
person_stub='',
tag='',
category_slug='',
is_ajax=False,
redirect_to_tags_page=False):
"""
adds a tag to a user if they do not have tagging turned off
"""
if req.method == 'POST':
if tag == '':
tag = req.POST.get('tag', '').strip()
if category_slug == '':
category_slug = req.POST.get('tag_category_slug', '').strip()
if tag == '':
return json_response(
{'error': 'Please enter a tag that is not blank.'})
elif person_stub == '':
return json_response({'error': 'Person not found.'})
person = Person.objects.get(stub=person_stub)
# make sure tag does not already exist
try:
taggeditem = TaggedItem.objects.get(
tag_category__slug=category_slug,
object_id=person.id,
tag__name__iexact=tag)
except Exception:
taggeditem = add_tags(person, tag, category_slug, req.user,
'person')
person.expire_cache()
expire_cache_group('tags')
url = reverse('staff_directory:person', args=[person.stub])
if person.user != req.user:
email_info = EmailInfo(
subject='You were tagged in the staff directory!',
text_template='staff_directory/email/user_tagged.txt',
html_template='staff_directory/email/user_tagged.html',
to_address=person.user.email,
)
# set notification
title = '%s %s tagged you with "%s"' % \
(req.user.first_name, req.user.last_name, tag)
Notification.set_notification(req.user, req.user, "tagged", tag,
person.user, title, url, email_info)
if is_ajax:
if redirect_to_tags_page:
return json_response({
'redirect':
reverse('staff_directory:show_by_tag',
args=[taggeditem.tag.slug])
})
return json_response({
'redirect':
reverse('staff_directory:person', args=[person.stub])
})
else:
return HttpResponseRedirect(
reverse('staff_directory:person', args=[person.stub]))
def test_org_group_page_with_tags(self):
"""
Tests the org group filters by tag.
"""
org = OrgGroup.objects.filter(pk=69)[0]
person_tagged = org.person_set.all()[0]
person_not_tagged = org.person_set.all()[1]
add_tags(person_tagged, 'TagA',
'staff-directory-my-expertise', person_tagged.user, 'person')
resp = self.client.get(reverse(
'staff_directory:org_group_with_tags', args=(org.title, 'taga')))
self.assertContains(resp, escape(
person_tagged.full_name), status_code=200)
self.assertNotContains(resp, escape(
person_not_tagged.full_name), status_code=200)
def test_profile_page_with_removed_tagger(self):
"""
Tests the profile page appears with no errors.
"""
person = Person.objects.all()[1]
user = get_user_model()(first_name="Baba", last_name="O'Reilly")
user.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
add_tags(person, 'TagA',
'staff-directory-test-category', user, 'person')
resp = self.client.get(reverse('staff_directory:person', args=(person.stub,)))
self.assertContains(resp, person.full_name, status_code=200)
def test_multiple_tags_single_user(self):
user = UserF(username="******")
person = Person(user=user)
person.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
tags = []
tagged_item = add_tags(person, 'TagA', 'staff-directory-test-category',
user, 'person')
tags.append(tagged_item.tag.slug)
tagged_item = add_tags(person, 'TagB', 'staff-directory-test-category',
user, 'person')
tags.append(tagged_item.tag.slug)
emails = _get_emails_for_tag(tags)
self.assertTrue(len(emails) == 1)
self.assertIn(user.email, emails)
def test_multiple_tags_single_user(self):
user = UserF(username="******")
person = Person(user=user)
person.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
tags = []
tagged_item = add_tags(person, 'TagA',
'staff-directory-test-category', user, 'person')
tags.append(tagged_item.tag.slug)
tagged_item = add_tags(person, 'TagB',
'staff-directory-test-category', user, 'person')
tags.append(tagged_item.tag.slug)
emails = _get_emails_for_tag(tags)
self.assertTrue(len(emails) == 1)
self.assertIn(user.email, emails)
def test_tag_remove_not_exists_for_different_idea(self):
"""
Detail page does not allow for removal of tags created by a different user
"""
user1 = login(self)
user2 = random_user()
idea = models.Idea(creator=user1,
title='AAAA',
state=models.State.objects.get(name='Active'))
idea.save()
idea2 = models.Idea(creator=user2,
title='BBBB',
state=models.State.objects.get(name='Active'))
idea2.save()
add_tags(idea, 'AAA', None, user1, 'idea')
add_tags(idea2, 'AAA', None, user2, 'idea')
response = self.client.get(
reverse("idea:idea_detail", args=(str(idea2.id), )))
self.assertContains(response, 'aaa')
self.assertNotContains(response, 'tag_remove')
def test_add_tags_duplicate_tag(self):
"""
add_tags function should only create a Tag if it doesn't already exist
"""
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
# test exact duplicate
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
# test duplicate with different category/user/content_type
user2 = self.random_user()
category2 = self.random_tag_category()
food_model2 = Pet
food_model2.objects.create(name="apple")
add_tags(apple, 'green', category2.slug, user2, 'pet')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
def test_add_tags_duplicate_tag(self):
"""
add_tags function should only create a Tag if it doesn't already exist
"""
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
# test exact duplicate
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
# test duplicate with different category/user/content_type
user2 = self.random_user()
category2 = self.random_tag_category()
food_model2 = Pet
food_model2.objects.create(name="apple")
add_tags(apple, 'green', category2.slug, user2, 'pet')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
def test_create_tags_for_person(self):
user = UserF(username="******")
person = Person(user=user)
person.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
tagged_item = add_tags(person, 'TagA',
'staff-directory-test-category', user, 'person')
self.assertEqual(1, person.tags.count())
def test_create_tags_for_person(self):
user = UserF(username="******")
person = Person(user=user)
person.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
tagged_item = add_tags(person, 'TagA', 'staff-directory-test-category',
user, 'person')
self.assertEqual(1, person.tags.count())
def test_tag_remove(self):
"""
Detail page tag form submission should add tags.
"""
user1 = random_user()
idea = models.Idea(creator=user1, title='AAAA',
state = models.State.objects.get(name='Active'))
idea.save()
add_tags(idea, 'AAA', None, user1, 'idea')
# Attempting to remove as a different user fails
req = RequestFactory().post('/', {})
req.user = random_user()
response = views.remove_tag(req, str(idea.id), 'aaa')
self.assertEqual(response.status_code, 302)
self.assertIn('aaa', set([tag.slug for tag in idea.tags.all()]))
# Attempting to remove as the creator succeeds
req.user = user1
response = views.remove_tag(req, str(idea.id), 'aaa')
self.assertEqual(response.status_code, 302)
self.assertNotIn('aaa', set([tag.slug for tag in idea.tags.all()]))
def add_tag(req, person_stub='', tag='', category_slug='', is_ajax=False,
redirect_to_tags_page=False):
"""
adds a tag to a user if they do not have tagging turned off
"""
if req.method == 'POST':
if tag == '':
tag = req.POST.get('tag', '').strip()
if category_slug == '':
category_slug = req.POST.get('tag_category_slug', '').strip()
if tag == '':
return json_response({'error':
'Please enter a tag that is not blank.'})
elif person_stub == '':
return json_response({'error':
'Person not found.'})
person = Person.objects.get(stub=person_stub)
# make sure tag does not already exist
try:
taggeditem = TaggedItem.objects.get(
tag_category__slug=category_slug, object_id=person.id,
tag__name__iexact=tag)
except Exception:
taggeditem = add_tags(person, tag, category_slug, req.user,
'person')
person.expire_cache()
expire_cache_group('tags')
url = reverse('staff_directory:person', args=[person.stub])
if person.user != req.user:
email_info = EmailInfo(
subject='You were tagged in the staff directory!',
text_template='staff_directory/email/user_tagged.txt',
html_template='staff_directory/email/user_tagged.html',
to_address=person.user.email,
)
# set notification
title = '%s %s tagged you with "%s"' % \
(req.user.first_name, req.user.last_name, tag)
Notification.set_notification(req.user, req.user, "tagged", tag,
person.user, title, url, email_info)
if is_ajax:
if redirect_to_tags_page:
return json_response({'redirect':
reverse('staff_directory:show_by_tag',
args=[taggeditem.tag.slug])})
return json_response({'redirect':
reverse('staff_directory:person', args=[person.stub])})
else:
return HttpResponseRedirect(reverse('staff_directory:person',
args=[person.stub]))
def test_tag_remove(self):
"""
Detail page tag form submission should add tags.
"""
user1 = random_user()
idea = models.Idea(creator=user1,
title='AAAA',
state=models.State.objects.get(name='Active'))
idea.save()
add_tags(idea, 'AAA', None, user1, 'idea')
# Attempting to remove as a different user fails
req = RequestFactory().post('/', {})
req.user = random_user()
response = views.remove_tag(req, str(idea.id), 'aaa')
self.assertEqual(response.status_code, 302)
self.assertIn('aaa', set([tag.slug for tag in idea.tags.all()]))
# Attempting to remove as the creator succeeds
req.user = user1
response = views.remove_tag(req, str(idea.id), 'aaa')
self.assertEqual(response.status_code, 302)
self.assertNotIn('aaa', set([tag.slug for tag in idea.tags.all()]))
def test_no_emails(self):
user1 = UserF(username="******")
person1 = Person(user=user1)
person1.save()
user2 = UserF(username="******")
person2 = Person(user=user2)
person2.save()
tag_category = TagCategory(name='Test Category',
slug='staff-directory-test-category')
tag_category.save()
tags = []
tagged_item = add_tags(person1, 'TagA',
'staff-directory-test-category', user1, 'person')
tags.append(tagged_item.tag.slug)
tagged_item = add_tags(person2, 'TagB',
'staff-directory-test-category', user1, 'person')
tags.append(tagged_item.tag.slug)
emails = _get_emails_for_tag(tags)
self.assertEqual(len(emails), 0)
def test_add_tags_util(self):
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='food'),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category1),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user1), [('apple', 'green')])
# test null category
user2 = self.random_user()
add_tags(apple, 'yellow', None, user2, 'food')
self.assert_tags_equal(apple.tags.all(), ['green', 'yellow'])
self.assert_tags_equal(food_model.tags.all(), ['green', 'yellow'])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='food'),
[('apple', 'green'), ('apple', 'yellow')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=None),
[('apple', 'yellow')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user2),
[('apple', 'yellow')])
# test null user
category2 = self.random_tag_category()
add_tags(apple, 'red', category2.slug, None, 'food')
self.assert_tags_equal(apple.tags.all(), ['green', 'yellow', 'red'])
self.assert_tags_equal(food_model.tags.all(),
['green', 'yellow', 'red'])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='food'),
[('apple', 'green'), ('apple', 'yellow'), ('apple', 'red')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category2),
[('apple', 'red')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=None), [('apple', 'red')])
# test null content_type
self.assertRaises(IndexError, add_tags, apple, 'red', category2.slug,
user2, 'bad_content_type')
self.assertRaises(IndexError, add_tags, apple, 'red', category2.slug,
user2, None)
def test_add_tags_util(self):
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='food'),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category1),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user1),
[('apple','green')])
# test null category
user2 = self.random_user()
add_tags(apple, 'yellow', None, user2, 'food')
self.assert_tags_equal(apple.tags.all(), ['green', 'yellow'])
self.assert_tags_equal(food_model.tags.all(), ['green', 'yellow'])
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='food'),
[('apple','green'), ('apple','yellow')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=None),
[('apple','yellow')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user2),
[('apple','yellow')])
# test null user
category2 = self.random_tag_category()
add_tags(apple, 'red', category2.slug, None, 'food')
self.assert_tags_equal(apple.tags.all(), ['green', 'yellow', 'red'])
self.assert_tags_equal(food_model.tags.all(), ['green', 'yellow', 'red'])
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='food'),
[('apple','green'), ('apple','yellow'), ('apple','red')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category2),
[('apple','red')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=None),
[('apple','red')])
# test null content_type
self.assertRaises(IndexError, add_tags, apple, 'red', category2.slug, user2, 'bad_content_type')
self.assertRaises(IndexError, add_tags, apple, 'red', category2.slug, user2, None)
def test_add_tags_duplicate_taggeditem(self):
"""
add_tags function should only create a TaggedItem if it doesn't
already exist
"""
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='food'),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category1),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user1),
[('apple','green')])
# test exact duplicate
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='food'),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category1),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user1),
[('apple','green')])
# test duplicate with different category
category2 = self.random_tag_category()
add_tags(apple, 'green', category2.slug, user1, 'food')
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='food'),
[('apple','green'), ('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category2),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user1),
[('apple','green'),('apple','green')])
# test duplicate with different content_type
food_model2 = Pet
food_model2.objects.create(name="apple", id=apple.id)
add_tags(apple, 'green', category2.slug, user1, 'pet')
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='pet'),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category2),
[('apple','green'),('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user1),
[('apple','green'),('apple','green'),('apple','green')])
# test duplicate with different creator
user2 = self.random_user()
add_tags(apple, 'green', category2.slug, user2, 'food')
self.assert_tagged_items_equal(TaggedItem.objects.filter(content_type__name='pet'),
[('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_category=category2),
[('apple','green'), ('apple','green')])
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user2),
[])
# ensure the old user didn't change either
self.assert_tagged_items_equal(TaggedItem.objects.filter(tag_creator=user1),
[('apple','green'),('apple','green'),('apple','green')])
def test_add_tags_duplicate_taggeditem(self):
"""
add_tags function should only create a TaggedItem if it doesn't
already exist
"""
food_model = Food
apple = food_model.objects.create(name="apple")
self.assertEqual(list(apple.tags.all()), [])
self.assertEqual(list(food_model.tags.all()), [])
user1 = self.random_user()
category1 = self.random_tag_category()
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tags_equal(apple.tags.all(), ['green'])
self.assert_tags_equal(food_model.tags.all(), ['green'])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='food'),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category1),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user1), [('apple', 'green')])
# test exact duplicate
add_tags(apple, 'green', category1.slug, user1, 'food')
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='food'),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category1),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user1), [('apple', 'green')])
# test duplicate with different category
category2 = self.random_tag_category()
add_tags(apple, 'green', category2.slug, user1, 'food')
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='food'),
[('apple', 'green'), ('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category2),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user1), [('apple', 'green'),
('apple', 'green')])
# test duplicate with different content_type
food_model2 = Pet
food_model2.objects.create(name="apple", id=apple.id)
add_tags(apple, 'green', category2.slug, user1, 'pet')
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='pet'),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category2),
[('apple', 'green'), ('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user1), [('apple', 'green'),
('apple', 'green'),
('apple', 'green')])
# test duplicate with different creator
user2 = self.random_user()
add_tags(apple, 'green', category2.slug, user2, 'food')
self.assert_tagged_items_equal(
TaggedItem.objects.filter(content_type__name='pet'),
[('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_category=category2),
[('apple', 'green'), ('apple', 'green')])
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user2), [])
# ensure the old user didn't change either
self.assert_tagged_items_equal(
TaggedItem.objects.filter(tag_creator=user1), [('apple', 'green'),
('apple', 'green'),
('apple', 'green')])
