From d65aa3c3c146b12548a54c894060bce9a8715ad2 Mon Sep 17 00:00:00 2001 From: Jonas Genannt Date: Sun, 15 Nov 2015 22:26:06 +0100 Subject: Imported Upstream version 0.4 --- tagging/tests/tests.py | 1386 +++++++++++++++++++++++++++++------------------- 1 file changed, 829 insertions(+), 557 deletions(-) (limited to 'tagging/tests/tests.py') diff --git a/tagging/tests/tests.py b/tagging/tests/tests.py index f5c9e37..c3ff3b6 100644 --- a/tagging/tests/tests.py +++ b/tagging/tests/tests.py @@ -1,434 +1,509 @@ # -*- coding: utf-8 -*- +from __future__ import unicode_literals import os + from django import forms +from django.utils import six from django.db.models import Q from django.test import TestCase -from tagging.forms import TagField +from django.test.utils import override_settings +from django.core.exceptions import ImproperlyConfigured + from tagging import settings -from tagging.models import Tag, TaggedItem -from tagging.tests.models import Article, Link, Perch, Parrot, FormTest -from tagging.utils import calculate_cloud, edit_string_for_tags, get_tag_list, get_tag, parse_tag_input +from tagging.forms import TagField +from tagging.forms import TagAdminForm +from tagging.models import Tag +from tagging.models import TaggedItem +from tagging.tests.models import Article +from tagging.tests.models import Link +from tagging.tests.models import Perch +from tagging.tests.models import Parrot +from tagging.tests.models import FormTest +from tagging.tests.models import FormTestNull from tagging.utils import LINEAR +from tagging.utils import get_tag +from tagging.utils import get_tag_list +from tagging.utils import calculate_cloud +from tagging.utils import parse_tag_input +from tagging.utils import edit_string_for_tags ############# # Utilities # ############# + class TestParseTagInput(TestCase): def test_with_simple_space_delimited_tags(self): """ Test with simple space-delimited tags. """ - - self.assertEquals(parse_tag_input('one'), [u'one']) - self.assertEquals(parse_tag_input('one two'), [u'one', u'two']) - self.assertEquals(parse_tag_input('one two three'), [u'one', u'three', u'two']) - self.assertEquals(parse_tag_input('one one two two'), [u'one', u'two']) - + + self.assertEqual(parse_tag_input('one'), ['one']) + self.assertEqual(parse_tag_input('one two'), ['one', 'two']) + self.assertEqual(parse_tag_input('one one two two'), ['one', 'two']) + self.assertEqual(parse_tag_input('one two three'), + ['one', 'three', 'two']) + def test_with_comma_delimited_multiple_words(self): """ Test with comma-delimited multiple words. An unquoted comma in the input will trigger this. """ - - self.assertEquals(parse_tag_input(',one'), [u'one']) - self.assertEquals(parse_tag_input(',one two'), [u'one two']) - self.assertEquals(parse_tag_input(',one two three'), [u'one two three']) - self.assertEquals(parse_tag_input('a-one, a-two and a-three'), - [u'a-one', u'a-two and a-three']) - + + self.assertEqual(parse_tag_input(',one'), ['one']) + self.assertEqual(parse_tag_input(',one two'), ['one two']) + self.assertEqual(parse_tag_input(',one two three'), ['one two three']) + self.assertEqual(parse_tag_input('a-one, a-two and a-three'), + ['a-one', 'a-two and a-three']) + def test_with_double_quoted_multiple_words(self): """ Test with double-quoted multiple words. - A completed quote will trigger this. Unclosed quotes are ignored. """ - - self.assertEquals(parse_tag_input('"one'), [u'one']) - self.assertEquals(parse_tag_input('"one two'), [u'one', u'two']) - self.assertEquals(parse_tag_input('"one two three'), [u'one', u'three', u'two']) - self.assertEquals(parse_tag_input('"one two"'), [u'one two']) - self.assertEquals(parse_tag_input('a-one "a-two and a-three"'), - [u'a-one', u'a-two and a-three']) - + A completed quote will trigger this. Unclosed quotes are ignored. + """ + + self.assertEqual(parse_tag_input('"one'), ['one']) + self.assertEqual(parse_tag_input('"one two'), ['one', 'two']) + self.assertEqual(parse_tag_input('"one two three'), + ['one', 'three', 'two']) + self.assertEqual(parse_tag_input('"one two"'), ['one two']) + self.assertEqual(parse_tag_input('a-one "a-two and a-three"'), + ['a-one', 'a-two and a-three']) + def test_with_no_loose_commas(self): """ Test with no loose commas -- split on spaces. """ - self.assertEquals(parse_tag_input('one two "thr,ee"'), [u'one', u'thr,ee', u'two']) - + self.assertEqual(parse_tag_input('one two "thr,ee"'), + ['one', 'thr,ee', 'two']) + def test_with_loose_commas(self): """ Loose commas - split on commas """ - self.assertEquals(parse_tag_input('"one", two three'), [u'one', u'two three']) - + self.assertEqual(parse_tag_input('"one", two three'), + ['one', 'two three']) + def test_tags_with_double_quotes_can_contain_commas(self): """ Double quotes can contain commas """ - self.assertEquals(parse_tag_input('a-one "a-two, and a-three"'), - [u'a-one', u'a-two, and a-three']) - self.assertEquals(parse_tag_input('"two", one, one, two, "one"'), - [u'one', u'two']) - + self.assertEqual(parse_tag_input('a-one "a-two, and a-three"'), + ['a-one', 'a-two, and a-three']) + self.assertEqual(parse_tag_input('"two", one, one, two, "one"'), + ['one', 'two']) + self.assertEqual(parse_tag_input('two", one'), + ['one', 'two']) + def test_with_naughty_input(self): """ Test with naughty input. """ - # Bad users! Naughty users! - self.assertEquals(parse_tag_input(None), []) - self.assertEquals(parse_tag_input(''), []) - self.assertEquals(parse_tag_input('"'), []) - self.assertEquals(parse_tag_input('""'), []) - self.assertEquals(parse_tag_input('"' * 7), []) - self.assertEquals(parse_tag_input(',,,,,,'), []) - self.assertEquals(parse_tag_input('",",",",",",","'), [u',']) - self.assertEquals(parse_tag_input('a-one "a-two" and "a-three'), - [u'a-one', u'a-three', u'a-two', u'and']) - + self.assertEqual(parse_tag_input(None), []) + self.assertEqual(parse_tag_input(''), []) + self.assertEqual(parse_tag_input('"'), []) + self.assertEqual(parse_tag_input('""'), []) + self.assertEqual(parse_tag_input('"' * 7), []) + self.assertEqual(parse_tag_input(',,,,,,'), []) + self.assertEqual(parse_tag_input('",",",",",",","'), [',']) + self.assertEqual(parse_tag_input('a-one "a-two" and "a-three'), + ['a-one', 'a-three', 'a-two', 'and']) + + class TestNormalisedTagListInput(TestCase): def setUp(self): - self.cheese = Tag.objects.create(name='cheese') self.toast = Tag.objects.create(name='toast') - + self.cheese = Tag.objects.create(name='cheese') + def test_single_tag_object_as_input(self): - self.assertEquals(get_tag_list(self.cheese), [self.cheese]) - + self.assertEqual(get_tag_list(self.cheese), [self.cheese]) + def test_space_delimeted_string_as_input(self): ret = get_tag_list('cheese toast') - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_comma_delimeted_string_as_input(self): ret = get_tag_list('cheese,toast') - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_with_empty_list(self): - self.assertEquals(get_tag_list([]), []) - + self.assertEqual(get_tag_list([]), []) + def test_list_of_two_strings(self): ret = get_tag_list(['cheese', 'toast']) - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_list_of_tag_primary_keys(self): ret = get_tag_list([self.cheese.id, self.toast.id]) - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_list_of_strings_with_strange_nontag_string(self): ret = get_tag_list(['cheese', 'toast', 'ŠĐĆŽćžšđ']) - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_list_of_tag_instances(self): ret = get_tag_list([self.cheese, self.toast]) - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_tuple_of_instances(self): ret = get_tag_list((self.cheese, self.toast)) - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_with_tag_filter(self): ret = get_tag_list(Tag.objects.filter(name__in=['cheese', 'toast'])) - self.assertEquals(len(ret), 2) - self.failUnless(self.cheese in ret) - self.failUnless(self.toast in ret) - + self.assertEqual(len(ret), 2) + self.assertTrue(self.cheese in ret) + self.assertTrue(self.toast in ret) + def test_with_invalid_input_mix_of_string_and_instance(self): try: get_tag_list(['cheese', self.toast]) - except ValueError, ve: - self.assertEquals(str(ve), - 'If a list or tuple of tags is provided, they must all be tag names, Tag objects or Tag ids.') - except Exception, e: - raise self.failureException('the wrong type of exception was raised: type [%s] value [%]' %\ + except ValueError as ve: + self.assertEqual( + str(ve), + 'If a list or tuple of tags is provided, they must all ' + 'be tag names, Tag objects or Tag ids.') + except Exception as e: + raise self.failureException( + 'the wrong type of exception was raised: type [%s] value [%]' % (str(type(e)), str(e))) else: - raise self.failureException('a ValueError exception was supposed to be raised!') - + raise self.failureException( + 'a ValueError exception was supposed to be raised!') + def test_with_invalid_input(self): try: get_tag_list(29) - except ValueError, ve: - self.assertEquals(str(ve), 'The tag input given was invalid.') - except Exception, e: - raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\ - (str(type(e)), str(e))) + except ValueError as ve: + self.assertEqual(str(ve), 'The tag input given was invalid.') + except Exception as e: + print('--', e) + raise self.failureException( + 'the wrong type of exception was raised: ' + 'type [%s] value [%s]' % (str(type(e)), str(e))) else: - raise self.failureException('a ValueError exception was supposed to be raised!') + raise self.failureException( + 'a ValueError exception was supposed to be raised!') def test_with_tag_instance(self): - self.assertEquals(get_tag(self.cheese), self.cheese) - + self.assertEqual(get_tag(self.cheese), self.cheese) + def test_with_string(self): - self.assertEquals(get_tag('cheese'), self.cheese) - + self.assertEqual(get_tag('cheese'), self.cheese) + def test_with_primary_key(self): - self.assertEquals(get_tag(self.cheese.id), self.cheese) - + self.assertEqual(get_tag(self.cheese.id), self.cheese) + def test_nonexistent_tag(self): - self.assertEquals(get_tag('mouse'), None) + self.assertEqual(get_tag('mouse'), None) + class TestCalculateCloud(TestCase): def setUp(self): self.tags = [] - for line in open(os.path.join(os.path.dirname(__file__), 'tags.txt')).readlines(): + for line in open(os.path.join(os.path.dirname(__file__), + 'tags.txt')).readlines(): name, count = line.rstrip().split() tag = Tag(name=name) tag.count = int(count) self.tags.append(tag) - + def test_default_distribution(self): sizes = {} for tag in calculate_cloud(self.tags, steps=5): sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1 - + # This isn't a pre-calculated test, just making sure it's consistent - self.assertEquals(sizes[1], 48) - self.assertEquals(sizes[2], 30) - self.assertEquals(sizes[3], 19) - self.assertEquals(sizes[4], 15) - self.assertEquals(sizes[5], 10) - + self.assertEqual(sizes[1], 48) + self.assertEqual(sizes[2], 30) + self.assertEqual(sizes[3], 19) + self.assertEqual(sizes[4], 15) + self.assertEqual(sizes[5], 10) + def test_linear_distribution(self): sizes = {} for tag in calculate_cloud(self.tags, steps=5, distribution=LINEAR): sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1 - + # This isn't a pre-calculated test, just making sure it's consistent - self.assertEquals(sizes[1], 97) - self.assertEquals(sizes[2], 12) - self.assertEquals(sizes[3], 7) - self.assertEquals(sizes[4], 2) - self.assertEquals(sizes[5], 4) - + self.assertEqual(sizes[1], 97) + self.assertEqual(sizes[2], 12) + self.assertEqual(sizes[3], 7) + self.assertEqual(sizes[4], 2) + self.assertEqual(sizes[5], 4) + def test_invalid_distribution(self): try: calculate_cloud(self.tags, steps=5, distribution='cheese') - except ValueError, ve: - self.assertEquals(str(ve), 'Invalid distribution algorithm specified: cheese.') - except Exception, e: - raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\ - (str(type(e)), str(e))) + except ValueError as ve: + self.assertEqual( + str(ve), 'Invalid distribution algorithm specified: cheese.') + except Exception as e: + raise self.failureException( + 'the wrong type of exception was raised: ' + 'type [%s] value [%s]' % (str(type(e)), str(e))) else: - raise self.failureException('a ValueError exception was supposed to be raised!') - + raise self.failureException( + 'a ValueError exception was supposed to be raised!') + ########### # Tagging # ########### + class TestBasicTagging(TestCase): def setUp(self): self.dead_parrot = Parrot.objects.create(state='dead') - + def test_update_tags(self): Tag.objects.update_tags(self.dead_parrot, 'foo,bar,"ter"') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('foo') in tags) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('ter') in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('foo') in tags) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('ter') in tags) + Tag.objects.update_tags(self.dead_parrot, '"foo" bar "baz"') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + def test_add_tag(self): # start off in a known, mildly interesting state Tag.objects.update_tags(self.dead_parrot, 'foo bar baz') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + # try to add a tag that already exists Tag.objects.add_tag(self.dead_parrot, 'foo') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + # now add a tag that doesn't already exist Tag.objects.add_tag(self.dead_parrot, 'zip') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 4) - self.failUnless(get_tag('zip') in tags) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - + self.assertEqual(len(tags), 4) + self.assertTrue(get_tag('zip') in tags) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + def test_add_tag_invalid_input_no_tags_specified(self): # start off in a known, mildly interesting state Tag.objects.update_tags(self.dead_parrot, 'foo bar baz') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + try: Tag.objects.add_tag(self.dead_parrot, ' ') - except AttributeError, ae: - self.assertEquals(str(ae), 'No tags were given: " ".') - except Exception, e: - raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\ - (str(type(e)), str(e))) + except AttributeError as ae: + self.assertEqual(str(ae), 'No tags were given: " ".') + except Exception as e: + raise self.failureException( + 'the wrong type of exception was raised: ' + 'type [%s] value [%s]' % (str(type(e)), str(e))) else: - raise self.failureException('an AttributeError exception was supposed to be raised!') - + raise self.failureException( + 'an AttributeError exception was supposed to be raised!') + def test_add_tag_invalid_input_multiple_tags_specified(self): # start off in a known, mildly interesting state Tag.objects.update_tags(self.dead_parrot, 'foo bar baz') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + try: Tag.objects.add_tag(self.dead_parrot, 'one two') - except AttributeError, ae: - self.assertEquals(str(ae), 'Multiple tags were given: "one two".') - except Exception, e: - raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\ - (str(type(e)), str(e))) + except AttributeError as ae: + self.assertEqual(str(ae), 'Multiple tags were given: "one two".') + except Exception as e: + raise self.failureException( + 'the wrong type of exception was raised: ' + 'type [%s] value [%s]' % (str(type(e)), str(e))) else: - raise self.failureException('an AttributeError exception was supposed to be raised!') - + raise self.failureException( + 'an AttributeError exception was supposed to be raised!') + def test_update_tags_exotic_characters(self): # start off in a known, mildly interesting state Tag.objects.update_tags(self.dead_parrot, 'foo bar baz') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - - Tag.objects.update_tags(self.dead_parrot, u'ŠĐĆŽćžšđ') + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + + Tag.objects.update_tags(self.dead_parrot, 'ŠĐĆŽćžšđ') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 1) - self.assertEquals(tags[0].name, u'ŠĐĆŽćžšđ') - - Tag.objects.update_tags(self.dead_parrot, u'你好') + self.assertEqual(len(tags), 1) + self.assertEqual(tags[0].name, 'ŠĐĆŽćžšđ') + + Tag.objects.update_tags(self.dead_parrot, '你好') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 1) - self.assertEquals(tags[0].name, u'你好') - + self.assertEqual(len(tags), 1) + self.assertEqual(tags[0].name, '你好') + + def test_unicode_tagged_object(self): + self.dead_parrot.state = "dëad" + self.dead_parrot.save() + Tag.objects.update_tags(self.dead_parrot, 'föo') + items = TaggedItem.objects.all() + self.assertEqual(len(items), 1) + self.assertEqual(six.text_type(items[0]), "dëad [föo]") + def test_update_tags_with_none(self): # start off in a known, mildly interesting state Tag.objects.update_tags(self.dead_parrot, 'foo bar baz') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(get_tag('bar') in tags) - self.failUnless(get_tag('baz') in tags) - self.failUnless(get_tag('foo') in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(get_tag('bar') in tags) + self.assertTrue(get_tag('baz') in tags) + self.assertTrue(get_tag('foo') in tags) + Tag.objects.update_tags(self.dead_parrot, None) tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 0) + self.assertEqual(len(tags), 0) + class TestModelTagField(TestCase): """ Test the 'tags' field on models. """ - + def test_create_with_tags_specified(self): - f1 = FormTest.objects.create(tags=u'test3 test2 test1') + f1 = FormTest.objects.create(tags='test3 test2 test1') tags = Tag.objects.get_for_object(f1) test1_tag = get_tag('test1') test2_tag = get_tag('test2') test3_tag = get_tag('test3') - self.failUnless(None not in (test1_tag, test2_tag, test3_tag)) - self.assertEquals(len(tags), 3) - self.failUnless(test1_tag in tags) - self.failUnless(test2_tag in tags) - self.failUnless(test3_tag in tags) - + self.assertTrue(None not in (test1_tag, test2_tag, test3_tag)) + self.assertEqual(len(tags), 3) + self.assertTrue(test1_tag in tags) + self.assertTrue(test2_tag in tags) + self.assertTrue(test3_tag in tags) + def test_update_via_tags_field(self): - f1 = FormTest.objects.create(tags=u'test3 test2 test1') + f1 = FormTest.objects.create(tags='test3 test2 test1') tags = Tag.objects.get_for_object(f1) test1_tag = get_tag('test1') test2_tag = get_tag('test2') test3_tag = get_tag('test3') - self.failUnless(None not in (test1_tag, test2_tag, test3_tag)) - self.assertEquals(len(tags), 3) - self.failUnless(test1_tag in tags) - self.failUnless(test2_tag in tags) - self.failUnless(test3_tag in tags) - - f1.tags = u'test4' + self.assertTrue(None not in (test1_tag, test2_tag, test3_tag)) + self.assertEqual(len(tags), 3) + self.assertTrue(test1_tag in tags) + self.assertTrue(test2_tag in tags) + self.assertTrue(test3_tag in tags) + + f1.tags = 'test4' f1.save() tags = Tag.objects.get_for_object(f1) test4_tag = get_tag('test4') - self.assertEquals(len(tags), 1) - self.assertEquals(tags[0], test4_tag) - + self.assertEqual(len(tags), 1) + self.assertEqual(tags[0], test4_tag) + f1.tags = '' f1.save() tags = Tag.objects.get_for_object(f1) - self.assertEquals(len(tags), 0) - + self.assertEqual(len(tags), 0) + + def disabledtest_update_via_tags(self): + # TODO: make this test working by reverting + # https://github.com/Fantomas42/django-tagging/commit/bbc7f25ea471dd903f39e08684d84ce59081bdef + f1 = FormTest.objects.create(tags='one two three') + Tag.objects.get(name='three').delete() + t2 = Tag.objects.get(name='two') + t2.name = 'new' + t2.save() + f1again = FormTest.objects.get(pk=f1.pk) + self.assertFalse('three' in f1again.tags) + self.assertFalse('two' in f1again.tags) + self.assertTrue('new' in f1again.tags) + + def test_creation_without_specifying_tags(self): + f1 = FormTest() + self.assertEqual(f1.tags, '') + + def test_creation_with_nullable_tags_field(self): + f1 = FormTestNull() + self.assertEqual(f1.tags, '') + + class TestSettings(TestCase): def setUp(self): self.original_force_lower_case_tags = settings.FORCE_LOWERCASE_TAGS self.dead_parrot = Parrot.objects.create(state='dead') - + def tearDown(self): settings.FORCE_LOWERCASE_TAGS = self.original_force_lower_case_tags - + def test_force_lowercase_tags(self): """ Test forcing tags to lowercase. """ - + settings.FORCE_LOWERCASE_TAGS = True - + Tag.objects.update_tags(self.dead_parrot, 'foO bAr Ter') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) + self.assertEqual(len(tags), 3) foo_tag = get_tag('foo') bar_tag = get_tag('bar') ter_tag = get_tag('ter') - self.failUnless(foo_tag in tags) - self.failUnless(bar_tag in tags) - self.failUnless(ter_tag in tags) - + self.assertTrue(foo_tag in tags) + self.assertTrue(bar_tag in tags) + self.assertTrue(ter_tag in tags) + Tag.objects.update_tags(self.dead_parrot, 'foO bAr baZ') tags = Tag.objects.get_for_object(self.dead_parrot) baz_tag = get_tag('baz') - self.assertEquals(len(tags), 3) - self.failUnless(bar_tag in tags) - self.failUnless(baz_tag in tags) - self.failUnless(foo_tag in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(bar_tag in tags) + self.assertTrue(baz_tag in tags) + self.assertTrue(foo_tag in tags) + Tag.objects.add_tag(self.dead_parrot, 'FOO') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 3) - self.failUnless(bar_tag in tags) - self.failUnless(baz_tag in tags) - self.failUnless(foo_tag in tags) - + self.assertEqual(len(tags), 3) + self.assertTrue(bar_tag in tags) + self.assertTrue(baz_tag in tags) + self.assertTrue(foo_tag in tags) + Tag.objects.add_tag(self.dead_parrot, 'Zip') tags = Tag.objects.get_for_object(self.dead_parrot) - self.assertEquals(len(tags), 4) + self.assertEqual(len(tags), 4) zip_tag = get_tag('zip') - self.failUnless(bar_tag in tags) - self.failUnless(baz_tag in tags) - self.failUnless(foo_tag in tags) - self.failUnless(zip_tag in tags) - + self.assertTrue(bar_tag in tags) + self.assertTrue(baz_tag in tags) + self.assertTrue(foo_tag in tags) + self.assertTrue(zip_tag in tags) + f1 = FormTest.objects.create() - f1.tags = u'TEST5' + f1.tags = 'TEST5' f1.save() tags = Tag.objects.get_for_object(f1) test5_tag = get_tag('test5') - self.assertEquals(len(tags), 1) - self.failUnless(test5_tag in tags) - self.assertEquals(f1.tags, u'test5') + self.assertEqual(len(tags), 1) + self.assertTrue(test5_tag in tags) + self.assertEqual(f1.tags, 'test5') + class TestTagUsageForModelBaseCase(TestCase): def test_tag_usage_for_model_empty(self): - self.assertEquals(Tag.objects.usage_for_model(Parrot), []) + self.assertEqual(Tag.objects.usage_for_model(Parrot), []) + class TestTagUsageForModel(TestCase): def setUp(self): @@ -438,75 +513,85 @@ class TestTagUsageForModel(TestCase): ('no more', 4, True, 'foo ter'), ('late', 2, False, 'bar ter'), ) - + for state, perch_size, perch_smelly, tags in parrot_details: perch = Perch.objects.create(size=perch_size, smelly=perch_smelly) parrot = Parrot.objects.create(state=state, perch=perch) Tag.objects.update_tags(parrot, tags) - + def test_tag_usage_for_model(self): tag_usage = Tag.objects.usage_for_model(Parrot, counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 4) - self.failUnless((u'bar', 3) in relevant_attribute_list) - self.failUnless((u'baz', 1) in relevant_attribute_list) - self.failUnless((u'foo', 2) in relevant_attribute_list) - self.failUnless((u'ter', 3) in relevant_attribute_list) - + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', 3) in relevant_attribute_list) + self.assertTrue(('baz', 1) in relevant_attribute_list) + self.assertTrue(('foo', 2) in relevant_attribute_list) + self.assertTrue(('ter', 3) in relevant_attribute_list) + def test_tag_usage_for_model_with_min_count(self): - tag_usage = Tag.objects.usage_for_model(Parrot, min_count = 2) + tag_usage = Tag.objects.usage_for_model(Parrot, min_count=2) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'bar', 3) in relevant_attribute_list) - self.failUnless((u'foo', 2) in relevant_attribute_list) - self.failUnless((u'ter', 3) in relevant_attribute_list) - + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('bar', 3) in relevant_attribute_list) + self.assertTrue(('foo', 2) in relevant_attribute_list) + self.assertTrue(('ter', 3) in relevant_attribute_list) + def test_tag_usage_with_filter_on_model_objects(self): - tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(state='no more')) + tag_usage = Tag.objects.usage_for_model( + Parrot, counts=True, filters=dict(state='no more')) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 2) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(state__startswith='p')) + self.assertEqual(len(relevant_attribute_list), 2) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_model( + Parrot, counts=True, filters=dict(state__startswith='p')) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 4) - self.failUnless((u'bar', 2) in relevant_attribute_list) - self.failUnless((u'baz', 1) in relevant_attribute_list) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(perch__size__gt=4)) + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', 2) in relevant_attribute_list) + self.assertTrue(('baz', 1) in relevant_attribute_list) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_model( + Parrot, counts=True, filters=dict(perch__size__gt=4)) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 4) - self.failUnless((u'bar', 2) in relevant_attribute_list) - self.failUnless((u'baz', 1) in relevant_attribute_list) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(perch__smelly=True)) + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', 2) in relevant_attribute_list) + self.assertTrue(('baz', 1) in relevant_attribute_list) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_model( + Parrot, counts=True, filters=dict(perch__smelly=True)) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'bar', 1) in relevant_attribute_list) - self.failUnless((u'foo', 2) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_model(Parrot, min_count=2, filters=dict(perch__smelly=True)) + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('bar', 1) in relevant_attribute_list) + self.assertTrue(('foo', 2) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_model( + Parrot, min_count=2, filters=dict(perch__smelly=True)) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'foo', 2) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_model(Parrot, filters=dict(perch__size__gt=4)) - relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 4) - self.failUnless((u'bar', False) in relevant_attribute_list) - self.failUnless((u'baz', False) in relevant_attribute_list) - self.failUnless((u'foo', False) in relevant_attribute_list) - self.failUnless((u'ter', False) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_model(Parrot, filters=dict(perch__size__gt=99)) - relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 0) + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('foo', 2) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_model( + Parrot, filters=dict(perch__size__gt=4)) + relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) + for tag in tag_usage] + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', False) in relevant_attribute_list) + self.assertTrue(('baz', False) in relevant_attribute_list) + self.assertTrue(('foo', False) in relevant_attribute_list) + self.assertTrue(('ter', False) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_model( + Parrot, filters=dict(perch__size__gt=99)) + relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) + for tag in tag_usage] + self.assertEqual(len(relevant_attribute_list), 0) + class TestTagsRelatedForModel(TestCase): def setUp(self): @@ -516,71 +601,134 @@ class TestTagsRelatedForModel(TestCase): ('no more', 4, True, 'foo ter'), ('late', 2, False, 'bar ter'), ) - + for state, perch_size, perch_smelly, tags in parrot_details: perch = Perch.objects.create(size=perch_size, smelly=perch_smelly) parrot = Parrot.objects.create(state=state, perch=perch) Tag.objects.update_tags(parrot, tags) - + def test_related_for_model_with_tag_query_sets_as_input(self): - related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, counts=True) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'baz', 1) in relevant_attribute_list) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 2) in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, min_count=2) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'ter', 2) in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, counts=False) + related_tags = Tag.objects.related_for_model( + Tag.objects.filter(name__in=['bar']), Parrot, counts=True) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('baz', 1) in relevant_attribute_list) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 2) in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + Tag.objects.filter(name__in=['bar']), Parrot, min_count=2) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('ter', 2) in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + Tag.objects.filter(name__in=['bar']), Parrot, counts=False) relevant_attribute_list = [tag.name for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless(u'baz' in relevant_attribute_list) - self.failUnless(u'foo' in relevant_attribute_list) - self.failUnless(u'ter' in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar', 'ter']), Parrot, counts=True) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'baz', 1) in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar', 'ter', 'baz']), Parrot, counts=True) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 0) - + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue('baz' in relevant_attribute_list) + self.assertTrue('foo' in relevant_attribute_list) + self.assertTrue('ter' in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + Tag.objects.filter(name__in=['bar', 'ter']), Parrot, counts=True) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('baz', 1) in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + Tag.objects.filter(name__in=['bar', 'ter', 'baz']), + Parrot, counts=True) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 0) + def test_related_for_model_with_tag_strings_as_input(self): # Once again, with feeling (strings) - related_tags = Tag.objects.related_for_model('bar', Parrot, counts=True) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'baz', 1) in relevant_attribute_list) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 2) in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model('bar', Parrot, min_count=2) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'ter', 2) in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model('bar', Parrot, counts=False) + related_tags = Tag.objects.related_for_model( + 'bar', Parrot, counts=True) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('baz', 1) in relevant_attribute_list) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 2) in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + 'bar', Parrot, min_count=2) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('ter', 2) in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + 'bar', Parrot, counts=False) relevant_attribute_list = [tag.name for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless(u'baz' in relevant_attribute_list) - self.failUnless(u'foo' in relevant_attribute_list) - self.failUnless(u'ter' in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model(['bar', 'ter'], Parrot, counts=True) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'baz', 1) in relevant_attribute_list) - - related_tags = Tag.objects.related_for_model(['bar', 'ter', 'baz'], Parrot, counts=True) - relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags] - self.assertEquals(len(relevant_attribute_list), 0) - + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue('baz' in relevant_attribute_list) + self.assertTrue('foo' in relevant_attribute_list) + self.assertTrue('ter' in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + ['bar', 'ter'], Parrot, counts=True) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('baz', 1) in relevant_attribute_list) + + related_tags = Tag.objects.related_for_model( + ['bar', 'ter', 'baz'], Parrot, counts=True) + relevant_attribute_list = [(tag.name, tag.count) + for tag in related_tags] + self.assertEqual(len(relevant_attribute_list), 0) + + +class TestTagCloudForModel(TestCase): + def setUp(self): + parrot_details = ( + ('pining for the fjords', 9, True, 'foo bar'), + ('passed on', 6, False, 'bar baz ter'), + ('no more', 4, True, 'foo ter'), + ('late', 2, False, 'bar ter'), + ) + + for state, perch_size, perch_smelly, tags in parrot_details: + perch = Perch.objects.create(size=perch_size, smelly=perch_smelly) + parrot = Parrot.objects.create(state=state, perch=perch) + Tag.objects.update_tags(parrot, tags) + + def test_tag_cloud_for_model(self): + tag_cloud = Tag.objects.cloud_for_model(Parrot) + relevant_attribute_list = [(tag.name, tag.count, tag.font_size) + for tag in tag_cloud] + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', 3, 4) in relevant_attribute_list) + self.assertTrue(('baz', 1, 1) in relevant_attribute_list) + self.assertTrue(('foo', 2, 2) in relevant_attribute_list) + self.assertTrue(('ter', 3, 4) in relevant_attribute_list) + + def test_tag_cloud_for_model_filters(self): + tag_cloud = Tag.objects.cloud_for_model(Parrot, + filters={'state': 'no more'}) + relevant_attribute_list = [(tag.name, tag.count, tag.font_size) + for tag in tag_cloud] + self.assertEqual(len(relevant_attribute_list), 2) + self.assertTrue(('foo', 1, 1) in relevant_attribute_list) + self.assertTrue(('ter', 1, 1) in relevant_attribute_list) + + def test_tag_cloud_for_model_min_count(self): + tag_cloud = Tag.objects.cloud_for_model(Parrot, min_count=2) + relevant_attribute_list = [(tag.name, tag.count, tag.font_size) + for tag in tag_cloud] + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('bar', 3, 4) in relevant_attribute_list) + self.assertTrue(('foo', 2, 1) in relevant_attribute_list) + self.assertTrue(('ter', 3, 4) in relevant_attribute_list) + + class TestGetTaggedObjectsByModel(TestCase): def setUp(self): parrot_details = ( @@ -589,112 +737,123 @@ class TestGetTaggedObjectsByModel(TestCase): ('no more', 4, True, 'foo ter'), ('late', 2, False, 'bar ter'), ) - + for state, perch_size, perch_smelly, tags in parrot_details: perch = Perch.objects.create(size=perch_size, smelly=perch_smelly) parrot = Parrot.objects.create(state=state, perch=perch) Tag.objects.update_tags(parrot, tags) - + self.foo = Tag.objects.get(name='foo') self.bar = Tag.objects.get(name='bar') self.baz = Tag.objects.get(name='baz') self.ter = Tag.objects.get(name='ter') - - self.pining_for_the_fjords_parrot = Parrot.objects.get(state='pining for the fjords') + + self.pining_for_the_fjords_parrot = Parrot.objects.get( + state='pining for the fjords') self.passed_on_parrot = Parrot.objects.get(state='passed on') self.no_more_parrot = Parrot.objects.get(state='no more') self.late_parrot = Parrot.objects.get(state='late') - + def test_get_by_model_simple(self): parrots = TaggedItem.objects.get_by_model(Parrot, self.foo) - self.assertEquals(len(parrots), 2) - self.failUnless(self.no_more_parrot in parrots) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - + self.assertEqual(len(parrots), 2) + self.assertTrue(self.no_more_parrot in parrots) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + parrots = TaggedItem.objects.get_by_model(Parrot, self.bar) - self.assertEquals(len(parrots), 3) - self.failUnless(self.late_parrot in parrots) - self.failUnless(self.passed_on_parrot in parrots) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - + self.assertEqual(len(parrots), 3) + self.assertTrue(self.late_parrot in parrots) + self.assertTrue(self.passed_on_parrot in parrots) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + def test_get_by_model_intersection(self): parrots = TaggedItem.objects.get_by_model(Parrot, [self.foo, self.baz]) - self.assertEquals(len(parrots), 0) - + self.assertEqual(len(parrots), 0) + parrots = TaggedItem.objects.get_by_model(Parrot, [self.foo, self.bar]) - self.assertEquals(len(parrots), 1) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - + self.assertEqual(len(parrots), 1) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + parrots = TaggedItem.objects.get_by_model(Parrot, [self.bar, self.ter]) - self.assertEquals(len(parrots), 2) - self.failUnless(self.late_parrot in parrots) - self.failUnless(self.passed_on_parrot in parrots) - + self.assertEqual(len(parrots), 2) + self.assertTrue(self.late_parrot in parrots) + self.assertTrue(self.passed_on_parrot in parrots) + # Issue 114 - Intersection with non-existant tags parrots = TaggedItem.objects.get_intersection_by_model(Parrot, []) - self.assertEquals(len(parrots), 0) - + self.assertEqual(len(parrots), 0) + def test_get_by_model_with_tag_querysets_as_input(self): - parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['foo', 'baz'])) - self.assertEquals(len(parrots), 0) - - parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['foo', 'bar'])) - self.assertEquals(len(parrots), 1) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - - parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['bar', 'ter'])) - self.assertEquals(len(parrots), 2) - self.failUnless(self.late_parrot in parrots) - self.failUnless(self.passed_on_parrot in parrots) - + parrots = TaggedItem.objects.get_by_model( + Parrot, Tag.objects.filter(name__in=['foo', 'baz'])) + self.assertEqual(len(parrots), 0) + + parrots = TaggedItem.objects.get_by_model( + Parrot, Tag.objects.filter(name__in=['foo', 'bar'])) + self.assertEqual(len(parrots), 1) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + + parrots = TaggedItem.objects.get_by_model( + Parrot, Tag.objects.filter(name__in=['bar', 'ter'])) + self.assertEqual(len(parrots), 2) + self.assertTrue(self.late_parrot in parrots) + self.assertTrue(self.passed_on_parrot in parrots) + def test_get_by_model_with_strings_as_input(self): parrots = TaggedItem.objects.get_by_model(Parrot, 'foo baz') - self.assertEquals(len(parrots), 0) - + self.assertEqual(len(parrots), 0) + parrots = TaggedItem.objects.get_by_model(Parrot, 'foo bar') - self.assertEquals(len(parrots), 1) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - + self.assertEqual(len(parrots), 1) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + parrots = TaggedItem.objects.get_by_model(Parrot, 'bar ter') - self.assertEquals(len(parrots), 2) - self.failUnless(self.late_parrot in parrots) - self.failUnless(self.passed_on_parrot in parrots) - + self.assertEqual(len(parrots), 2) + self.assertTrue(self.late_parrot in parrots) + self.assertTrue(self.passed_on_parrot in parrots) + def test_get_by_model_with_lists_of_strings_as_input(self): parrots = TaggedItem.objects.get_by_model(Parrot, ['foo', 'baz']) - self.assertEquals(len(parrots), 0) - + self.assertEqual(len(parrots), 0) + parrots = TaggedItem.objects.get_by_model(Parrot, ['foo', 'bar']) - self.assertEquals(len(parrots), 1) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - + self.assertEqual(len(parrots), 1) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + parrots = TaggedItem.objects.get_by_model(Parrot, ['bar', 'ter']) - self.assertEquals(len(parrots), 2) - self.failUnless(self.late_parrot in parrots) - self.failUnless(self.passed_on_parrot in parrots) - + self.assertEqual(len(parrots), 2) + self.assertTrue(self.late_parrot in parrots) + self.assertTrue(self.passed_on_parrot in parrots) + def test_get_by_nonexistent_tag(self): # Issue 50 - Get by non-existent tag parrots = TaggedItem.objects.get_by_model(Parrot, 'argatrons') - self.assertEquals(len(parrots), 0) - + self.assertEqual(len(parrots), 0) + def test_get_union_by_model(self): parrots = TaggedItem.objects.get_union_by_model(Parrot, ['foo', 'ter']) - self.assertEquals(len(parrots), 4) - self.failUnless(self.late_parrot in parrots) - self.failUnless(self.no_more_parrot in parrots) - self.failUnless(self.passed_on_parrot in parrots) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - + self.assertEqual(len(parrots), 4) + self.assertTrue(self.late_parrot in parrots) + self.assertTrue(self.no_more_parrot in parrots) + self.assertTrue(self.passed_on_parrot in parrots) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + parrots = TaggedItem.objects.get_union_by_model(Parrot, ['bar', 'baz']) - self.assertEquals(len(parrots), 3) - self.failUnless(self.late_parrot in parrots) - self.failUnless(self.passed_on_parrot in parrots) - self.failUnless(self.pining_for_the_fjords_parrot in parrots) - + self.assertEqual(len(parrots), 3) + self.assertTrue(self.late_parrot in parrots) + self.assertTrue(self.passed_on_parrot in parrots) + self.assertTrue(self.pining_for_the_fjords_parrot in parrots) + # Issue 114 - Union with non-existant tags parrots = TaggedItem.objects.get_union_by_model(Parrot, []) - self.assertEquals(len(parrots), 0) + self.assertEqual(len(parrots), 0) + parrots = TaggedItem.objects.get_union_by_model(Parrot, ['albert']) + self.assertEqual(len(parrots), 0) + + Tag.objects.create(name='titi') + parrots = TaggedItem.objects.get_union_by_model(Parrot, ['titi']) + self.assertEqual(len(parrots), 0) + class TestGetRelatedTaggedItems(TestCase): def setUp(self): @@ -704,12 +863,12 @@ class TestGetRelatedTaggedItems(TestCase): ('no more', 4, True, 'foo ter'), ('late', 2, False, 'bar ter'), ) - + for state, perch_size, perch_smelly, tags in parrot_details: perch = Perch.objects.create(size=perch_size, smelly=perch_smelly) parrot = Parrot.objects.create(state=state, perch=perch) Tag.objects.update_tags(parrot, tags) - + self.l1 = Link.objects.create(name='link 1') Tag.objects.update_tags(self.l1, 'tag1 tag2 tag3 tag4 tag5') self.l2 = Link.objects.create(name='link 2') @@ -717,44 +876,46 @@ class TestGetRelatedTaggedItems(TestCase): self.l3 = Link.objects.create(name='link 3') Tag.objects.update_tags(self.l3, 'tag1') self.l4 = Link.objects.create(name='link 4') - + self.a1 = Article.objects.create(name='article 1') Tag.objects.update_tags(self.a1, 'tag1 tag2 tag3 tag4') - + def test_get_related_objects_of_same_model(self): related_objects = TaggedItem.objects.get_related(self.l1, Link) - self.assertEquals(len(related_objects), 2) - self.failUnless(self.l2 in related_objects) - self.failUnless(self.l3 in related_objects) - + self.assertEqual(len(related_objects), 2) + self.assertTrue(self.l2 in related_objects) + self.assertTrue(self.l3 in related_objects) + related_objects = TaggedItem.objects.get_related(self.l4, Link) - self.assertEquals(len(related_objects), 0) - + self.assertEqual(len(related_objects), 0) + def test_get_related_objects_of_same_model_limited_number_of_results(self): # This fails on Oracle because it has no support for a 'LIMIT' clause. - # See http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:127412348064 - + # See http://bit.ly/1AYNEsa + # ask for no more than 1 result related_objects = TaggedItem.objects.get_related(self.l1, Link, num=1) - self.assertEquals(len(related_objects), 1) - self.failUnless(self.l2 in related_objects) - + self.assertEqual(len(related_objects), 1) + self.assertTrue(self.l2 in related_objects) + def test_get_related_objects_of_same_model_limit_related_items(self): - related_objects = TaggedItem.objects.get_related(self.l1, Link.objects.exclude(name='link 3')) - self.assertEquals(len(related_objects), 1) - self.failUnless(self.l2 in related_objects) - + related_objects = TaggedItem.objects.get_related( + self.l1, Link.objects.exclude(name='link 3')) + self.assertEqual(len(related_objects), 1) + self.assertTrue(self.l2 in related_objects) + def test_get_related_objects_of_different_model(self): related_objects = TaggedItem.objects.get_related(self.a1, Link) - self.assertEquals(len(related_objects), 3) - self.failUnless(self.l1 in related_objects) - self.failUnless(self.l2 in related_objects) - self.failUnless(self.l3 in related_objects) - + self.assertEqual(len(related_objects), 3) + self.assertTrue(self.l1 in related_objects) + self.assertTrue(self.l2 in related_objects) + self.assertTrue(self.l3 in related_objects) + Tag.objects.update_tags(self.a1, 'tag6') related_objects = TaggedItem.objects.get_related(self.a1, Link) - self.assertEquals(len(related_objects), 0) - + self.assertEqual(len(related_objects), 0) + + class TestTagUsageForQuerySet(TestCase): def setUp(self): parrot_details = ( @@ -763,102 +924,125 @@ class TestTagUsageForQuerySet(TestCase): ('no more', 4, True, 'foo ter'), ('late', 2, False, 'bar ter'), ) - + for state, perch_size, perch_smelly, tags in parrot_details: perch = Perch.objects.create(size=perch_size, smelly=perch_smelly) parrot = Parrot.objects.create(state=state, perch=perch) Tag.objects.update_tags(parrot, tags) - + def test_tag_usage_for_queryset(self): - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(state='no more'), counts=True) + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(state='no more'), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 2) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(state__startswith='p'), counts=True) + self.assertEqual(len(relevant_attribute_list), 2) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(state__startswith='p'), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 4) - self.failUnless((u'bar', 2) in relevant_attribute_list) - self.failUnless((u'baz', 1) in relevant_attribute_list) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=4), counts=True) + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', 2) in relevant_attribute_list) + self.assertTrue(('baz', 1) in relevant_attribute_list) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(perch__size__gt=4), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 4) - self.failUnless((u'bar', 2) in relevant_attribute_list) - self.failUnless((u'baz', 1) in relevant_attribute_list) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__smelly=True), counts=True) + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', 2) in relevant_attribute_list) + self.assertTrue(('baz', 1) in relevant_attribute_list) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(perch__smelly=True), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'bar', 1) in relevant_attribute_list) - self.failUnless((u'foo', 2) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__smelly=True), min_count=2) + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('bar', 1) in relevant_attribute_list) + self.assertTrue(('foo', 2) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(perch__smelly=True), min_count=2) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'foo', 2) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=4)) - relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 4) - self.failUnless((u'bar', False) in relevant_attribute_list) - self.failUnless((u'baz', False) in relevant_attribute_list) - self.failUnless((u'foo', False) in relevant_attribute_list) - self.failUnless((u'ter', False) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=99)) - relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 0) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')), counts=True) + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('foo', 2) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(perch__size__gt=4)) + relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) + for tag in tag_usage] + self.assertEqual(len(relevant_attribute_list), 4) + self.assertTrue(('bar', False) in relevant_attribute_list) + self.assertTrue(('baz', False) in relevant_attribute_list) + self.assertTrue(('foo', False) in relevant_attribute_list) + self.assertTrue(('ter', False) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(perch__size__gt=99)) + relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) + for tag in tag_usage] + self.assertEqual(len(relevant_attribute_list), 0) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(Q(perch__size__gt=6) | + Q(state__startswith='l')), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'bar', 2) in relevant_attribute_list) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')), min_count=2) + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('bar', 2) in relevant_attribute_list) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(Q(perch__size__gt=6) | + Q(state__startswith='l')), min_count=2) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'bar', 2) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l'))) - relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'bar', False) in relevant_attribute_list) - self.failUnless((u'foo', False) in relevant_attribute_list) - self.failUnless((u'ter', False) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(state='passed on'), counts=True) + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('bar', 2) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.filter(Q(perch__size__gt=6) | + Q(state__startswith='l'))) + relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) + for tag in tag_usage] + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('bar', False) in relevant_attribute_list) + self.assertTrue(('foo', False) in relevant_attribute_list) + self.assertTrue(('ter', False) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.exclude(state='passed on'), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 3) - self.failUnless((u'bar', 2) in relevant_attribute_list) - self.failUnless((u'foo', 2) in relevant_attribute_list) - self.failUnless((u'ter', 2) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(state__startswith='p'), min_count=2) + self.assertEqual(len(relevant_attribute_list), 3) + self.assertTrue(('bar', 2) in relevant_attribute_list) + self.assertTrue(('foo', 2) in relevant_attribute_list) + self.assertTrue(('ter', 2) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.exclude(state__startswith='p'), min_count=2) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 1) - self.failUnless((u'ter', 2) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(Q(perch__size__gt=6) | Q(perch__smelly=False)), counts=True) + self.assertEqual(len(relevant_attribute_list), 1) + self.assertTrue(('ter', 2) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.exclude(Q(perch__size__gt=6) | + Q(perch__smelly=False)), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 2) - self.failUnless((u'foo', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - - tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(perch__smelly=True).filter(state__startswith='l'), counts=True) + self.assertEqual(len(relevant_attribute_list), 2) + self.assertTrue(('foo', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + tag_usage = Tag.objects.usage_for_queryset( + Parrot.objects.exclude(perch__smelly=True).filter( + state__startswith='l'), counts=True) relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage] - self.assertEquals(len(relevant_attribute_list), 2) - self.failUnless((u'bar', 1) in relevant_attribute_list) - self.failUnless((u'ter', 1) in relevant_attribute_list) - + self.assertEqual(len(relevant_attribute_list), 2) + self.assertTrue(('bar', 1) in relevant_attribute_list) + self.assertTrue(('ter', 1) in relevant_attribute_list) + + ################ # Model Fields # ################ @@ -869,33 +1053,121 @@ class TestTagFieldInForms(TestCase): class TestForm(forms.ModelForm): class Meta: model = FormTest - + fields = forms.ALL_FIELDS + form = TestForm() - self.assertEquals(form.fields['tags'].__class__.__name__, 'TagField') - + self.assertEqual(form.fields['tags'].__class__.__name__, 'TagField') + def test_recreation_of_tag_list_string_representations(self): plain = Tag.objects.create(name='plain') spaces = Tag.objects.create(name='spa ces') comma = Tag.objects.create(name='com,ma') - self.assertEquals(edit_string_for_tags([plain]), u'plain') - self.assertEquals(edit_string_for_tags([plain, spaces]), u'plain, spa ces') - self.assertEquals(edit_string_for_tags([plain, spaces, comma]), u'plain, spa ces, "com,ma"') - self.assertEquals(edit_string_for_tags([plain, comma]), u'plain "com,ma"') - self.assertEquals(edit_string_for_tags([comma, spaces]), u'"com,ma", spa ces') - + self.assertEqual(edit_string_for_tags([plain]), 'plain') + self.assertEqual(edit_string_for_tags([plain, spaces]), + 'plain, spa ces') + self.assertEqual(edit_string_for_tags([plain, spaces, comma]), + 'plain, spa ces, "com,ma"') + self.assertEqual(edit_string_for_tags([plain, comma]), + 'plain "com,ma"') + self.assertEqual(edit_string_for_tags([comma, spaces]), + '"com,ma", spa ces') + def test_tag_d_validation(self): - t = TagField() - self.assertEquals(t.clean('foo'), u'foo') - self.assertEquals(t.clean('foo bar baz'), u'foo bar baz') - self.assertEquals(t.clean('foo,bar,baz'), u'foo,bar,baz') - self.assertEquals(t.clean('foo, bar, baz'), u'foo, bar, baz') - self.assertEquals(t.clean('foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar'), - u'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar') - try: - t.clean('foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbn bar') - except forms.ValidationError, ve: - self.assertEquals(str(ve), "[u'Each tag may be no more than 50 characters long.']") - except Exception, e: - raise e - else: - raise self.failureException('a ValidationError exception was supposed to have been raised.') + t = TagField(required=False) + self.assertEqual(t.clean(''), '') + self.assertEqual(t.clean('foo'), 'foo') + self.assertEqual(t.clean('foo bar baz'), 'foo bar baz') + self.assertEqual(t.clean('foo,bar,baz'), 'foo,bar,baz') + self.assertEqual(t.clean('foo, bar, baz'), 'foo, bar, baz') + self.assertEqual( + t.clean('foo qwertyuiopasdfghjklzxcvbnm' + 'qwertyuiopasdfghjklzxcvb bar'), + 'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar') + self.assertRaises( + forms.ValidationError, t.clean, + 'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbn bar') + + def test_tag_get_from_model(self): + FormTest.objects.create(tags='test3 test2 test1') + FormTest.objects.create(tags='toto titi') + self.assertEquals(FormTest.tags, 'test1 test2 test3 titi toto') + + +######### +# Forms # +######### + + +class TestTagAdminForm(TestCase): + + def test_clean_name(self): + datas = {'name': 'tag'} + form = TagAdminForm(datas) + self.assertTrue(form.is_valid()) + + def test_clean_name_multi(self): + datas = {'name': 'tag error'} + form = TagAdminForm(datas) + self.assertFalse(form.is_valid()) + + def test_clean_name_too_long(self): + datas = {'name': 't' * (settings.MAX_TAG_LENGTH + 1)} + form = TagAdminForm(datas) + self.assertFalse(form.is_valid()) + +######### +# Views # +######### + + +@override_settings( + ROOT_URLCONF='tagging.tests.urls', + TEMPLATE_LOADERS=( + 'tagging.tests.utils.VoidLoader', + ), +) +class TestTaggedObjectList(TestCase): + + def setUp(self): + self.a1 = Article.objects.create(name='article 1') + self.a2 = Article.objects.create(name='article 2') + Tag.objects.update_tags(self.a1, 'static tag test') + Tag.objects.update_tags(self.a2, 'static test') + + def get_view(self, url, queries=1, code=200, + expected_items=1, + friendly_context='article_list', + template='tests/article_list.html'): + with self.assertNumQueries(queries): + response = self.client.get(url) + self.assertEquals(response.status_code, code) + + if code == 200: + self.assertTrue(isinstance(response.context['tag'], Tag)) + self.assertEqual(len(response.context['object_list']), + expected_items) + self.assertEqual(response.context['object_list'], + response.context[friendly_context]) + self.assertTemplateUsed(response, template) + return response + + def test_view_static(self): + self.get_view('/static/', expected_items=2) + + def test_view_dynamic(self): + self.get_view('/tag/', expected_items=1) + + def test_view_related(self): + response = self.get_view('/static/related/', + queries=2, expected_items=2) + self.assertEquals(len(response.context['related_tags']), 2) + + def test_view_no_queryset_no_model(self): + self.assertRaises(ImproperlyConfigured, self.get_view, + '/no-query-no-model/') + + def test_view_no_tag(self): + self.assertRaises(AttributeError, self.get_view, '/no-tag/') + + def test_view_404(self): + self.get_view('/unavailable/', code=404) -- cgit v1.2.3