def test_related_name_for_author(self):
item0 = TaggedItemFactory(author=self.user)
item1 = TaggedItemFactory(author=self.user)
TaggedItemFactory()
self.assertEqual(self.user.items.count(), 2)
self.assertEqual(self.user.items.all()[0], item0)
self.assertEqual(self.user.items.all()[1], item1)
def test_related_name_for_tag(self):
tag = TagFactory()
item0 = TaggedItemFactory(tag=tag)
item1 = TaggedItemFactory(tag=tag)
TaggedItemFactory()
self.assertEqual(tag.items.count(), 2)
self.assertEqual(tag.items.all()[0], item0)
self.assertEqual(tag.items.all()[1], item1)
def test_order(self):
item0 = TaggedItemFactory(order=2)
item1 = TaggedItemFactory(order=5)
item2 = TaggedItemFactory(order=0)
items = TaggedItem.objects.all()
self.assertEqual(items[0], item2)
self.assertEqual(items[1], item0)
self.assertEqual(items[2], item1)
def test_items(self):
tag = TagFactory()
item0 = TaggedItemFactory(content_object=TagTestArticle0Factory(),
tag=tag)
item1 = TaggedItemFactory(content_object=TagTestArticle1Factory(),
tag=tag)
self.assertEqual(tag.items.count(), 2)
self.assertEqual(tag.items.all()[0], item0)
self.assertEqual(tag.items.all()[1], item1)
def test_get_tag_count(self):
TaggedItemFactory(content_object=self.article)
TaggedItemFactory(content_object=self.article)
TaggedItemFactory(content_object=self.article)
TaggedItemFactory(content_object=self.other_article)
self.assertEqual(TaggedItem.objects.get_tag_count(self.article), 3)
self.assertEqual(TaggedItem.objects.get_tag_count(self.other_article),
1)
def test_swap_tags(self):
tagged_item0 = TaggedItemFactory(content_object=self.article, order=10)
tagged_item1 = TaggedItemFactory(content_object=self.article, order=20)
self.assertEqual(tagged_item0.order, 10)
self.assertEqual(tagged_item1.order, 20)
TaggedItem.objects.swap_order(tagged_item0, tagged_item1)
self.assertEqual(tagged_item0.order, 20)
self.assertEqual(tagged_item1.order, 10)
def test_swap_tags_with_different_models(self):
tagged_item0 = TaggedItemFactory(content_object=self.article, order=10)
tagged_item1 = TaggedItemFactory(content_object=self.other_article,
order=20)
self.assertEqual(tagged_item0.order, 10)
self.assertEqual(tagged_item1.order, 20)
self.assertRaises(CannotReorderException,
TaggedItem.objects.swap_order, tagged_item0,
tagged_item1)
def test_clear(self):
TaggedItemFactory(content_object=self.article)
TaggedItemFactory(content_object=self.article)
TaggedItemFactory(content_object=self.article)
TaggedItemFactory(content_object=self.other_article)
self.assertEqual(len(Tag.objects.get_for_object(self.article)), 3)
self.assertEqual(len(Tag.objects.get_for_object(self.other_article)),
1)
TaggedItem.objects.clear(self.article)
self.assertEqual(len(Tag.objects.get_for_object(self.article)), 0)
self.assertEqual(len(Tag.objects.get_for_object(self.other_article)),
1)
def test_unlock_for_unlocked_item(self):
self.client.login(username=self.user.username, password='******')
item = TaggedItemFactory()
r = self.client.patch('/api/tagged_items/%d/unlock/' % item.pk)
self.assertEqual(r.status_code, 400)
self.assertFalse(TaggedItem.objects.get(pk=item.pk).locked)
def test_get_for_object(self):
article = TagTestArticle0Factory()
other_article = TagTestArticle0Factory()
TaggedItemFactory(tag=self.tag, content_object=article)
TaggedItemFactory(tag=self.other_tag, content_object=article)
TaggedItemFactory(tag=self.tag, content_object=other_article)
TaggedItemFactory(tag=self.other_tag, content_object=other_article)
tags0 = Tag.objects.get_for_object(article)
self.assertEqual(tags0[0], self.tag)
self.assertEqual(tags0[1], self.other_tag)
tags1 = Tag.objects.get_for_object(other_article)
self.assertEqual(tags1[0], self.tag)
self.assertEqual(tags1[1], self.other_tag)
def test_get_for_object(self):
article = TagTestArticle0Factory()
other_article = TagTestArticle0Factory()
tagged_item0 = TaggedItemFactory(content_object=article)
tagged_item1 = TaggedItemFactory(content_object=article)
tagged_item2 = TaggedItemFactory(content_object=other_article)
tagged_item3 = TaggedItemFactory(content_object=other_article)
items0 = TaggedItem.objects.get_for_object(article)
self.assertEqual(items0[0], tagged_item0)
self.assertEqual(items0[1], tagged_item1)
items1 = TaggedItem.objects.get_for_object(other_article)
self.assertEqual(items1[0], tagged_item2)
self.assertEqual(items1[1], tagged_item3)
def test_remove(self):
item0 = TaggedItemFactory(tag__label='Unnecessary label',
content_object=self.article)
item1 = TaggedItemFactory(tag__label='Necessary label',
content_object=self.article)
TaggedItemFactory(tag__label='Unnecessary label',
content_object=self.other_article)
self.assertEqual(len(Tag.objects.get_for_object(self.article)), 2)
self.assertEqual(len(Tag.objects.get_for_object(self.other_article)),
1)
TaggedItem.objects.remove('Unnecessary label', self.article)
self.assertEqual(len(Tag.objects.get_for_object(self.article)), 1)
self.assertEqual(len(Tag.objects.get_for_object(self.other_article)),
1)
self.assertNotIn(item0.tag, Tag.objects.get_for_object(self.article))
self.assertIn(item1.tag, Tag.objects.get_for_object(self.article))
def test_create_with_already_added(self):
article = TagTestArticle0Factory()
ct = ContentType.objects.get_for_model(article)
item = TaggedItemFactory(content_object=article,
tag__label='already added')
r = self.client.post('/api/tagged_items/', {
'tag': 'already added',
'object_id': article.pk,
'content_type': ct.pk
})
self.assertEqual(r.status_code, 400)
self.assertEqual(r.data, "'already added' is already added.")
def test_read(self):
tagged_item = TaggedItemFactory()
serializer = TaggedItemSerializer(tagged_item)
data = serializer.data
self.assertEqual(data['author'], tagged_item.author.pk)
self.assertIsNotNone(data['created_at'])
self.assertEqual(data['object_id'], tagged_item.object_id)
self.assertEqual(data['content_type'], tagged_item.content_type.pk)
self.assertFalse(data['locked'])
self.assertEqual(data['tag']['id'], tagged_item.tag.pk)
self.assertEqual(data['tag']['label'], tagged_item.tag.label)
self.assertEqual(data['detail_api_url'],
'/api/tagged_items/%d/' % tagged_item.pk)
self.assertEqual(data['lock_api_url'],
'/api/tagged_items/%d/lock/' % tagged_item.pk)
self.assertEqual(data['unlock_api_url'],
'/api/tagged_items/%d/unlock/' % tagged_item.pk)
def test_unlock_with_not_locked_item(self):
item = TaggedItemFactory()
self.assertFalse(item.locked)
self.assertRaises(ValidationError, item.unlock)
def test_unlock(self):
item = TaggedItemFactory(locked=True)
self.assertTrue(item.locked)
item.unlock()
self.assertFalse(item.locked)
def test_lock_with_locked_item(self):
item = TaggedItemFactory(locked=True)
self.assertTrue(item.locked)
self.assertRaises(ValidationError, item.lock)
def test_update(self):
item = TaggedItemFactory()
r = self.client.patch('/api/tagged_items/%d/' % item.pk,
{'locked': False})
self.assertEqual(r.status_code, 405)
def test_str(self):
item = TaggedItemFactory(tag__label='Label')
self.assertEqual(str(item), 'Label TagTestArticle0 object')
def test_delete(self):
item = TaggedItemFactory()
count = TaggedItem.objects.count()
r = self.client.delete('/api/tagged_items/%d/' % item.pk)
self.assertEqual(r.status_code, 204)
self.assertEqual(TaggedItem.objects.count(), count - 1)
def test_delete_with_locked(self):
item = TaggedItemFactory(locked=True)
count = TaggedItem.objects.count()
r = self.client.delete('/api/tagged_items/%d/' % item.pk)
self.assertEqual(r.status_code, 400)
self.assertEqual(TaggedItem.objects.count(), count)
def test_list_with_object_id_only(self):
article0 = TagTestArticle0Factory()
TaggedItemFactory(content_object=article0)
r = self.client.get('/api/tagged_items/', {'object_id': article0.pk})
self.assertEqual(r.status_code, 400)
def test_delete_for_unlocked_item(self):
item = TaggedItemFactory()
self.assertIn(item, TaggedItem.objects.all())
item.delete()
self.assertNotIn(item, TaggedItem.objects.all())
def test_unlock(self):
item = TaggedItemFactory(locked=True)
self.assertTrue(item.locked)
item.unlock()
self.assertFalse(item.locked)
def test_delete_for_unlocked_item(self):
item = TaggedItemFactory()
self.assertIn(item, TaggedItem.objects.all())
item.delete()
self.assertNotIn(item, TaggedItem.objects.all())
def test_list_with_content_type_only(self):
article0 = TagTestArticle0Factory()
TaggedItemFactory(content_object=article0)
ct = ContentType.objects.get_for_model(article0)
r = self.client.get('/api/tagged_items/', {'content_type': ct.pk})
self.assertEqual(r.status_code, 400)
def test_list_with_object(self):
article0 = TagTestArticle0Factory()
article1 = TagTestArticle1Factory()
tagged_item0 = TaggedItemFactory(content_object=article0)
tagged_item1 = TaggedItemFactory(content_object=article0)
tagged_item2 = TaggedItemFactory(content_object=article1)
ct0 = ContentType.objects.get_for_model(article0)
ct1 = ContentType.objects.get_for_model(article1)
with patch.object(TagTestArticle0,
'get_absolute_url',
create=True,
return_value='/absolute_url/'):
r = self.client.get('/api/tagged_items/', {
'content_type': ct0.pk,
'object_id': article0.pk
})
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.data), 2)
self.assertEqual(r.data[0]['id'], tagged_item0.pk)
self.assertEqual(r.data[1]['id'], tagged_item1.pk)
self.assertEqual(
r.data[0], {
'id':
tagged_item0.pk,
'content_type':
tagged_item0.content_type.pk,
'object_id':
tagged_item0.object_id,
'content_object': {
'content_type': tagged_item0.content_type.pk,
'object_id': tagged_item0.object_id,
'str': str(tagged_item0.content_object),
'url': '/absolute_url/'
},
'author':
tagged_item0.author.pk,
'locked':
False,
'created_at':
tagged_item0.created_at.isoformat(),
'tag': {
'label': tagged_item0.tag.label,
'id': tagged_item0.tag.pk,
'url': '/%s/' % quote(tagged_item0.tag.label)
},
'detail_api_url':
'/api/tagged_items/%d/' % tagged_item0.pk,
'lock_api_url':
'/api/tagged_items/%d/lock/' % tagged_item0.pk,
'unlock_api_url':
'/api/tagged_items/%d/unlock/' % tagged_item0.pk,
})
r = self.client.get('/api/tagged_items/', {
'content_type': ct1.pk,
'object_id': article1.pk
})
self.assertEqual(r.status_code, 200)
self.assertEqual(len(r.data), 1)
self.assertEqual(r.data[0]['id'], tagged_item2.pk)
self.assertEqual(
r.data[0], {
'id': tagged_item2.pk,
'content_type': tagged_item2.content_type.pk,
'object_id': tagged_item2.object_id,
'content_object': {
'content_type': tagged_item2.content_type.pk,
'object_id': tagged_item2.object_id,
'str': str(tagged_item2.content_object),
'url': None
},
'author': tagged_item2.author.pk,
'locked': False,
'created_at': tagged_item2.created_at.isoformat(),
'tag': {
'label': tagged_item2.tag.label,
'id': tagged_item2.tag.pk,
'url': '/%s/' % quote(tagged_item2.tag.label)
},
'detail_api_url': '/api/tagged_items/%d/' % tagged_item2.pk,
'lock_api_url': '/api/tagged_items/%d/lock/' % tagged_item2.pk,
'unlock_api_url':
'/api/tagged_items/%d/unlock/' % tagged_item2.pk,
})
def test_delete_for_locked_item(self):
item = TaggedItemFactory(locked=True)
self.assertIn(item, TaggedItem.objects.all())
self.assertRaises(CannotDeleteLockedTagException, item.delete)
self.assertIn(item, TaggedItem.objects.all())
def test_retrieve(self):
tagged_item = TaggedItemFactory()
r = self.client.get('/api/tagged_items/%d/' % tagged_item.pk)
self.assertEqual(r.status_code, 405)
