Python utils.get_tag函数代码示例

    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.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.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.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 relate(self, tags, relation_type='~', related_tags=[], force_create=False):
     '''
     Relates each tag in a list of tags with each tag in a list of related_tags
     with the given relation type. Tag lists can be Tag instances or strings.
     Relations are created symmetrically. If force_create = True, tags are 
     created from string if they do not already exist. If just a list of tags are 
     given, it calls relate_all() to relate them with each other using '~' relation.
     Updates existing relations if needed.
     '''
     #TODO: WTF
     tags = get_tag_list(tags)
     if related_tags == []:
         self.relate_all(tags)
     else:
         related_tags = get_tag_list(related_tags)
         for tag in tags:
             tag = get_tag(tag)
             if tag and tag.is_valid:
                     for related_tag in related_tags:
                         related_tag = get_tag(related_tag)
                         if related_tag and related_tag.is_valid:
                                 if tag != related_tag:
                                     rel, c = RelatedTag.objects.get_or_create(tag=tag, related_tag=related_tag,
                                                                               defaults={'relation_type': relation_type,
                                                                                         'count': 1})
                                     if not c:
                                         rel.count += 1
                                         # check if the existing relation is correct
                                         if rel.relation_type != relation_type:
                                             rel.relation_type = relation_type
                                         rel.save()

 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)
     ##TODO: for some reason this doesn't work
     #self.assertEquals(len(tags), 3)
     ## But this does!
     self.assertEquals(len(list(tags)), 3)
     self.failUnless(get_tag('bar') in tags)
     self.failUnless(get_tag('baz') in tags)
     self.failUnless(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)
     
     # 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)

    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)

        # 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)

        # 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)

 def test_update_via_tags_field(self):
     f1 = FormTest.objects.create(tags=u'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))
     ##TODO: for some reason this doesn't work
     #self.assertEquals(len(tags), 3)
     ## But this does!
     self.assertEquals(len(list(tags)), 3)
     self.failUnless(test1_tag in tags)
     self.failUnless(test2_tag in tags)
     self.failUnless(test3_tag in tags)
     
     f1.tags = u'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)
     
     f1.tags = ''
     f1.save()
     tags = Tag.objects.get_for_object(f1)
     self.assertEquals(len(tags), 0)

 def test_create_with_tags_specified(self):
     f1 = FormTest.objects.create(tags=u'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)

 def test_create_with_tags_specified(self):
     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.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_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.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.assertEqual(len(tags), 0)

    def testMergeTagsCreatesSynonyms(self):
        first = TestItem(title = 'first', tags = 'one, two')
        first.save()
        second = TestItem(title = 'second', tags = 'second')
        second.save()

        self.assertEqual([], [s.name for s in get_tag('two').synonyms.all()])

        ctype = model_to_ctype(TestItem)
        merge('two', 'second', ctype)

        self.assertEqual(['second'], [s.name for s in get_tag('two').synonyms.all()])

    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)

        Tag.objects.update_tags(self.dead_parrot, None)
        tags = Tag.objects.get_for_object(self.dead_parrot)
        self.assertEquals(len(tags), 0)

    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)

        try:
            Tag.objects.add_tag(self.dead_parrot, "    ")
        except AttributeError, ae:
            self.assertEquals(str(ae), 'No tags were given: "    ".')

    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)

        try:
            Tag.objects.add_tag(self.dead_parrot, 'one two')
        except AttributeError, ae:
            self.assertEquals(str(ae), 'Multiple tags were given: "one two".')

 def test_create_with_tags_specified(self):
     f1 = FormTest.objects.create(tags=u'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))
     ##TODO: for some reason this doesn't work
     #self.assertEquals(len(tags), 3)
     ## But this does!
     self.assertEquals(len(list(tags)), 3)
     self.failUnless(test1_tag in tags)
     self.failUnless(test2_tag in tags)
     self.failUnless(test3_tag in tags)

    def testMergeTagsWhenSynonymAlreadyExists(self):
        first = TestItem(title = 'first', tags = 'one, two, blah')
        first.save()
        second = TestItem(title = 'second', tags = 'second')
        second.save()
        blah = get_tag('blah')
        blah.synonyms.create(name='second')

        self.assertEqual([], [s.name for s in get_tag('two').synonyms.all()])

        ctype = model_to_ctype(TestItem)
        merge('two', 'second', ctype)

        self.assertEqual([], [s.name for s in get_tag('two').synonyms.all()])
        self.assertEqual(['second'], [s.name for s in get_tag('blah').synonyms.all()])

 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)
     ##TODO: for some reason this doesn't work
     #self.assertEquals(len(tags), 3)
     ## But this does!
     self.assertEquals(len(list(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, None)
     tags = Tag.objects.get_for_object(self.dead_parrot)
     self.assertEquals(len(tags), 0)