Fixed tag sync and tests

boards/models/post/sync.py

@@ -1,385 +1,385 b''
 import xml.etree.ElementTree as et
 import logging
 from xml.etree import ElementTree
 
 from boards.abstracts.exceptions import SyncException
 from boards.abstracts.sync_filters import ThreadFilter, TagsFilter,\
         TimestampFromFilter
 from boards.models import KeyPair, GlobalId, Signature, Post, Tag
 from boards.models.attachment.downloaders import download
 from boards.models.signature import TAG_REQUEST, ATTR_TYPE, TYPE_GET, \
     ATTR_VERSION, TAG_MODEL, ATTR_NAME, TAG_ID, TYPE_LIST
 from boards.utils import get_file_mimetype, get_file_hash
 from django.db import transaction
 
 EXCEPTION_NODE = 'Sync node returned an error: {}.'
 EXCEPTION_DOWNLOAD = 'File was not downloaded.'
 EXCEPTION_HASH = 'File hash does not match attachment hash.'
 EXCEPTION_SIGNATURE = 'Invalid model signature for {}.'
 EXCEPTION_AUTHOR_SIGNATURE = 'Model {} has no author signature.'
 EXCEPTION_THREAD = 'No thread exists for post {}'
 ENCODING_UNICODE = 'unicode'
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_RESPONSE = 'response'
 TAG_ID = 'id'
 TAG_STATUS = 'status'
 TAG_MODELS = 'models'
 TAG_TITLE = 'title'
 TAG_TEXT = 'text'
 TAG_THREAD = 'thread'
 TAG_PUB_TIME = 'pub-time'
 TAG_SIGNATURES = 'signatures'
 TAG_SIGNATURE = 'signature'
 TAG_CONTENT = 'content'
 TAG_ATTACHMENTS = 'attachments'
 TAG_ATTACHMENT = 'attachment'
 TAG_TAGS = 'tags'
 TAG_TAG = 'tag'
 TAG_ATTACHMENT_REFS = 'attachment-refs'
 TAG_ATTACHMENT_REF = 'attachment-ref'
 TAG_TRIPCODE = 'tripcode'
 TAG_VERSION = 'version'
 
 TYPE_GET = 'get'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 ATTR_VALUE = 'value'
 ATTR_MIMETYPE = 'mimetype'
 ATTR_KEY = 'key'
 ATTR_REF = 'ref'
 ATTR_URL = 'url'
 ATTR_ID_TYPE = 'id-type'
 
 ID_TYPE_MD5 = 'md5'
 ID_TYPE_URL = 'url'
 
 STATUS_SUCCESS = 'success'
 
 
 logger = logging.getLogger('boards.sync')
 
 
 class SyncManager:
     @staticmethod
     def generate_response_get(model_list: list):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         for post in model_list:
             model = et.SubElement(models, TAG_MODEL)
             model.set(ATTR_NAME, 'post')
 
             global_id = post.global_id
 
             attachments = post.attachments.all()
             if global_id.content:
                 model.append(et.fromstring(global_id.content))
                 if len(attachments) > 0:
                     internal_attachments = False
                     for attachment in attachments:
                         if attachment.is_internal():
                             internal_attachments = True
                             break
 
                     if internal_attachments:
                         attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
                         for file in attachments:
                             SyncManager._attachment_to_xml(
                                 None, attachment_refs, file)
             else:
                 content_tag = et.SubElement(model, TAG_CONTENT)
 
                 tag_id = et.SubElement(content_tag, TAG_ID)
                 global_id.to_xml_element(tag_id)
 
                 title = et.SubElement(content_tag, TAG_TITLE)
                 title.text = post.title
 
                 text = et.SubElement(content_tag, TAG_TEXT)
                 text.text = post.get_sync_text()
 
                 thread = post.get_thread()
                 if post.is_opening():
                     tag_tags = et.SubElement(content_tag, TAG_TAGS)
                     for tag in thread.get_tags():
                         tag_tag = et.SubElement(tag_tags, TAG_TAG)
-                        tag_tag.text = tag.name
+                        tag_tag.text = tag.get_name()
                 else:
                     tag_thread = et.SubElement(content_tag, TAG_THREAD)
                     thread_id = et.SubElement(tag_thread, TAG_ID)
                     thread.get_opening_post().global_id.to_xml_element(thread_id)
 
                 pub_time = et.SubElement(content_tag, TAG_PUB_TIME)
                 pub_time.text = str(post.get_pub_time_str())
 
                 if post.tripcode:
                     tripcode = et.SubElement(content_tag, TAG_TRIPCODE)
                     tripcode.text = post.tripcode
 
                 if len(attachments) > 0:
                     attachments_tag = et.SubElement(content_tag, TAG_ATTACHMENTS)
                     
                     internal_attachments = False
                     for attachment in attachments:
                         if attachment.is_internal():
                             internal_attachments = True
                             break
 
                     if internal_attachments:
                         attachment_refs = et.SubElement(model, TAG_ATTACHMENT_REFS)
                     else:
                         attachment_refs = None
 
                     for file in attachments:
                         SyncManager._attachment_to_xml(
                             attachments_tag, attachment_refs, file)
                 version_tag = et.SubElement(content_tag, TAG_VERSION)
                 version_tag.text = str(post.version)
 
                 global_id.content = et.tostring(content_tag, ENCODING_UNICODE)
                 global_id.save()
 
             signatures_tag = et.SubElement(model, TAG_SIGNATURES)
             post_signatures = global_id.signature_set.all()
             if post_signatures:
                 signatures = post_signatures
             else:
                 key = KeyPair.objects.get(public_key=global_id.key)
                 signature = Signature(
                     key_type=key.key_type,
                     key=key.public_key,
                     signature=key.sign(global_id.content),
                     global_id=global_id,
                 )
                 signature.save()
                 signatures = [signature]
             for signature in signatures:
                 signature_tag = et.SubElement(signatures_tag, TAG_SIGNATURE)
                 signature_tag.set(ATTR_TYPE, signature.key_type)
                 signature_tag.set(ATTR_VALUE, signature.signature)
                 signature_tag.set(ATTR_KEY, signature.key)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     def parse_response_get(response_xml, hostname):
         tag_root = et.fromstring(response_xml)
         tag_status = tag_root.find(TAG_STATUS)
         if STATUS_SUCCESS == tag_status.text:
             tag_models = tag_root.find(TAG_MODELS)
             for tag_model in tag_models:
                 SyncManager.parse_post(tag_model, hostname)
         else:
             raise SyncException(EXCEPTION_NODE.format(tag_status.text))
 
     @staticmethod
     @transaction.atomic
     def parse_post(tag_model, hostname):
         tag_content = tag_model.find(TAG_CONTENT)
 
         content_str = et.tostring(tag_content, ENCODING_UNICODE)
 
         tag_id = tag_content.find(TAG_ID)
         global_id, exists = GlobalId.from_xml_element(tag_id)
         signatures = SyncManager._verify_model(global_id, content_str, tag_model)
 
         version = int(tag_content.find(TAG_VERSION).text)
         is_old = exists and global_id.post.version < version
         if exists and not is_old:
             logger.debug('Post {} exists and is up to date.'.format(global_id))
         else:
             global_id.content = content_str
             global_id.save()
             for signature in signatures:
                 signature.global_id = global_id
                 signature.save()
 
             title = tag_content.find(TAG_TITLE).text or ''
             text = tag_content.find(TAG_TEXT).text or ''
             pub_time = tag_content.find(TAG_PUB_TIME).text
             tripcode_tag = tag_content.find(TAG_TRIPCODE)
             if tripcode_tag is not None:
                 tripcode = tripcode_tag.text or ''
             else:
                 tripcode = ''
 
             thread = tag_content.find(TAG_THREAD)
             tags = []
             if thread:
                 thread_id = thread.find(TAG_ID)
                 op_global_id, exists = GlobalId.from_xml_element(thread_id)
                 if exists:
                     opening_post = Post.objects.get(global_id=op_global_id)
                 else:
                     raise Exception(EXCEPTION_THREAD.format(global_id))
             else:
                 opening_post = None
                 tag_tags = tag_content.find(TAG_TAGS)
                 for tag_tag in tag_tags:
                     tag, created = Tag.objects.get_or_create(
-                        name=tag_tag.text)
+                        aliases__name=tag_tag.text)
                     tags.append(tag)
 
             # TODO Check that the replied posts are already present
             # before adding new ones
 
             files = []
             urls = []
             tag_attachments = tag_content.find(TAG_ATTACHMENTS) or list()
             tag_refs = tag_model.find(TAG_ATTACHMENT_REFS)
             for attachment in tag_attachments:
                 if attachment.get(ATTR_ID_TYPE) == ID_TYPE_URL:
                     urls.append(attachment.text)
                 else:
                     tag_ref = tag_refs.find("{}[@ref='{}']".format(
                         TAG_ATTACHMENT_REF, attachment.text))
                     url = tag_ref.get(ATTR_URL)
                     attached_file = download(hostname + url, validate=False)
                     if attached_file is None:
                         raise SyncException(EXCEPTION_DOWNLOAD)
 
                     hash = get_file_hash(attached_file)
                     if hash != attachment.text:
                         raise SyncException(EXCEPTION_HASH)
 
                     files.append(attached_file)
 
             if is_old:
                 post = global_id.post
                 Post.objects.update_post(
                     post, title=title, text=text, pub_time=pub_time,
                     tags=tags, files=files, file_urls=urls,
                     tripcode=tripcode, version=version)
                 logger.debug('Parsed updated post {}'.format(global_id))
             else:
                 Post.objects.import_post(
                     title=title, text=text, pub_time=pub_time,
                     opening_post=opening_post, tags=tags,
                     global_id=global_id, files=files,
                     file_urls=urls, tripcode=tripcode,
                     version=version)
                 logger.debug('Parsed new post {}'.format(global_id))
 
     @staticmethod
     def generate_response_list(filters):
         response = et.Element(TAG_RESPONSE)
 
         status = et.SubElement(response, TAG_STATUS)
         status.text = STATUS_SUCCESS
 
         models = et.SubElement(response, TAG_MODELS)
 
         posts = Post.objects.prefetch_related('global_id')
         for post_filter in filters:
             posts = post_filter.filter(posts)
 
         for post in posts:
             tag_model = et.SubElement(models, TAG_MODEL)
             tag_id = et.SubElement(tag_model, TAG_ID)
             post.global_id.to_xml_element(tag_id)
             tag_version = et.SubElement(tag_model, TAG_VERSION)
             tag_version.text = str(post.version)
 
         return et.tostring(response, ENCODING_UNICODE)
 
     @staticmethod
     def _verify_model(global_id, content_str, tag_model):
         """
         Verifies all signatures for a single model.
         """
 
         signatures = []
 
         tag_signatures = tag_model.find(TAG_SIGNATURES)
         has_author_signature = False
         for tag_signature in tag_signatures:
             signature_type = tag_signature.get(ATTR_TYPE)
             signature_value = tag_signature.get(ATTR_VALUE)
             signature_key = tag_signature.get(ATTR_KEY)
 
             if global_id.key_type == signature_type and\
                     global_id.key == signature_key:
                 has_author_signature = True
 
             signature = Signature(key_type=signature_type,
                                   key=signature_key,
                                   signature=signature_value)
 
             if not KeyPair.objects.verify(signature, content_str):
                 raise SyncException(EXCEPTION_SIGNATURE.format(content_str))
 
             signatures.append(signature)
         if not has_author_signature:
             raise SyncException(EXCEPTION_AUTHOR_SIGNATURE.format(content_str))
 
         return signatures
 
     @staticmethod
     def _attachment_to_xml(tag_attachments, tag_refs, attachment):
         if tag_attachments is not None:
             attachment_tag = et.SubElement(tag_attachments, TAG_ATTACHMENT)
             if attachment.is_internal():
                 mimetype = get_file_mimetype(attachment.file.file)
                 attachment_tag.set(ATTR_MIMETYPE, mimetype)
                 attachment_tag.set(ATTR_ID_TYPE, ID_TYPE_MD5)
                 attachment_tag.text = attachment.hash
             else:
                 attachment_tag.set(ATTR_ID_TYPE, ID_TYPE_URL)
                 attachment_tag.text = attachment.url
 
         if tag_refs is not None and attachment.is_internal():
             attachment_ref = et.SubElement(tag_refs, TAG_ATTACHMENT_REF)
             attachment_ref.set(ATTR_REF, attachment.hash)
             attachment_ref.set(ATTR_URL, attachment.file.url)
 
     @staticmethod
     def generate_request_get(global_id_list: list):
         """
         Form a get request from a list of ModelId objects.
         """
 
         request = et.Element(TAG_REQUEST)
         request.set(ATTR_TYPE, TYPE_GET)
         request.set(ATTR_VERSION, '1.0')
 
         model = et.SubElement(request, TAG_MODEL)
         model.set(ATTR_VERSION, '1.0')
         model.set(ATTR_NAME, 'post')
 
         for global_id in global_id_list:
             tag_id = et.SubElement(model, TAG_ID)
             global_id.to_xml_element(tag_id)
 
         return et.tostring(request, 'unicode')
 
     @staticmethod
     def generate_request_list(opening_post=None, tags=list(),
             timestamp_from=None):
         """
         Form a pull request from a list of ModelId objects.
         """
 
         request = et.Element(TAG_REQUEST)
         request.set(ATTR_TYPE, TYPE_LIST)
         request.set(ATTR_VERSION, '1.0')
 
         model = et.SubElement(request, TAG_MODEL)
         model.set(ATTR_VERSION, '1.0')
         model.set(ATTR_NAME, 'post')
 
         if opening_post:
             ThreadFilter().add_filter(model, opening_post)
         if tags:
             TagsFilter().add_filter(model, tags)
         if timestamp_from:
             TimestampFromFilter().add_filter(model, timestamp_from)
 
         return et.tostring(request, 'unicode')

boards/tests/test_api.py

@@ -1,70 +1,70 b''
 import simplejson
 
 from django.test import TestCase
 from boards.views import api
 
 from boards.models import Tag, Post
 from boards.tests.mocks import MockRequest
 from boards.utils import datetime_to_epoch
 
 
 class ApiTest(TestCase):
     def test_thread_diff(self):
-        tag = Tag.objects.create(name='test_tag')
+        tag, created = Tag.objects.get_or_create_with_alias(name='test_tag')
         opening_post = Post.objects.create_post(title='title', text='text',
                                                 tags=[tag])
 
         req = MockRequest()
         req.POST['thread'] = opening_post.id
         req.POST['uids'] = opening_post.uid
         # Check the exact timestamp post was added
         empty_response = api.api_get_threaddiff(req)
         diff = simplejson.loads(empty_response.content)
         self.assertEqual(0, len(diff['updated']),
                          'There must be no updated posts in the diff.')
 
         uids = [opening_post.uid]
 
         reply = Post.objects.create_post(title='',
                                          text='[post]%d[/post]\ntext' % opening_post.id,
                                          thread=opening_post.get_thread())
         req = MockRequest()
         req.POST['thread'] = opening_post.id
         req.POST['uids'] = ' '.join(uids)
         req.user = None
         # Check the timestamp before post was added
         response = api.api_get_threaddiff(req)
         diff = simplejson.loads(response.content)
         self.assertEqual(2, len(diff['updated']),
                          'There must be 2 updated posts in the diff.')
 
         # Reload post to get the new UID
         opening_post = Post.objects.get(id=opening_post.id)
         req = MockRequest()
         req.POST['thread'] = opening_post.id
         req.POST['uids'] = ' '.join([opening_post.uid, reply.uid])
         empty_response = api.api_get_threaddiff(req)
         diff = simplejson.loads(empty_response.content)
         self.assertEqual(0, len(diff['updated']),
                          'There must be no updated posts in the diff.')
 
     def test_get_threads(self):
         # Create 10 threads
-        tag = Tag.objects.create(name='test_tag')
+        tag, created = Tag.objects.get_or_create_with_alias(name='test_tag')
         for i in range(5):
             Post.objects.create_post(title='title', text='text', tags=[tag])
 
         # Get all threads
         response = api.api_get_threads(MockRequest(), 5)
         diff = simplejson.loads(response.content)
         self.assertEqual(5, len(diff), 'Invalid thread list response.')
 
         # Get less threads then exist
         response = api.api_get_threads(MockRequest(), 3)
         diff = simplejson.loads(response.content)
         self.assertEqual(3, len(diff), 'Invalid thread list response.')
 
         # Get more threads then exist
         response = api.api_get_threads(MockRequest(), 10)
         diff = simplejson.loads(response.content)
         self.assertEqual(5, len(diff), 'Invalid thread list response.')

boards/tests/test_forms.py

@@ -1,56 +1,56 b''
 from django.test import TestCase, Client
 import time
 from boards import settings
 from boards.models import Post, Tag
 import neboard
 
 
 TEST_TAG = 'test_tag'
 
 PAGE_404 = 'boards/404.html'
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 HTTP_CODE_REDIRECT = 302
 
 
 class FormTest(TestCase):
     def test_post_validation(self):
         client = Client()
 
         valid_tags = 'tag1 tag_2 тег_3'
         invalid_tags = '$%_356 ---'
-        Tag.objects.create(name='tag1', required=True)
+        Tag.objects.get_or_create_with_alias(name='tag1', required=True)
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         # Change posting delay so we don't have to wait for 30 seconds or more
         old_posting_delay = neboard.settings.POSTING_DELAY
         # Wait fot the posting delay or we won't be able to post
         neboard.settings.POSTING_DELAY = 1
         time.sleep(neboard.settings.POSTING_DELAY + 1)
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
         # Restore posting delay
         settings.POSTING_DELAY = old_posting_delay
 
         self.assertEqual(2, Post.objects.count(),
                          msg='No posts were created')

boards/tests/test_pages.py

@@ -1,52 +1,52 b''
 from django.test import TestCase, Client
 from boards.models import Tag, Post
 
 TEST_TEXT = 'test'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
 HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
 
 class PagesTest(TestCase):
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         tag_name = 'test_tag'
-        tag = Tag.objects.create(name=tag_name)
+        tag, created = Tag.objects.get_or_create_with_alias(name=tag_name)
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=[tag])
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
         self.assertEqual(HTTP_CODE_NOT_FOUND, response_not_existing.status_code,
                          'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + 'not_tag' + '/')
         self.assertEqual(HTTP_CODE_NOT_FOUND, response_not_existing.status_code,
                          'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             thread=Post.objects.all()[0]
                                             .get_thread()).id
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(HTTP_CODE_REDIRECT, response_not_existing.status_code,
                          'Reply is opened as a thread')

boards/tests/test_post.py

@@ -1,176 +1,176 b''
 from django.core.paginator import Paginator
 from django.test import TestCase
 
 from boards import settings
 from boards.models import Tag, Post, Thread, KeyPair
 from boards.models.thread import STATUS_ARCHIVE
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
-        tag, created = Tag.objects.get_or_create(name='test_tag')
+        tag, created = Tag.objects.get_or_create_with_alias(name='test_tag')
         return Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
 
     def test_post_add(self):
         """Test adding post"""
 
         post = self._create_post()
 
         self.assertIsNotNone(post, 'No post was created.')
-        self.assertEqual('test_tag', post.get_thread().tags.all()[0].name,
+        self.assertEqual('test_tag', post.get_thread().tags.all()[0].get_name(),
                          'No tags were added to the post.')
 
     def test_delete_post(self):
         """Test post deletion"""
 
         post = self._create_post()
         post_id = post.id
 
         post.delete()
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_delete_thread(self):
         """Test thread deletion"""
 
         opening_post = self._create_post()
         thread = opening_post.get_thread()
         reply = Post.objects.create_post("", "", thread=thread)
 
         thread.delete()
 
         self.assertFalse(Post.objects.filter(id=reply.id).exists(),
                          'Reply was not deleted with the thread.')
         self.assertFalse(Post.objects.filter(id=opening_post.id).exists(),
                          'Opening post was not deleted with the thread.')
 
     def test_post_to_thread(self):
         """Test adding post to a thread"""
 
         op = self._create_post()
         post = Post.objects.create_post("", "", thread=op.get_thread())
 
         self.assertIsNotNone(post, 'Reply to thread wasn\'t created')
         self.assertEqual(op.get_thread().last_edit_time, post.pub_time,
                          'Post\'s create time doesn\'t match thread last edit'
                          ' time')
 
     def test_delete_posts_by_ip(self):
         """Test deleting posts with the given ip"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_get_thread(self):
         """Test getting all posts of a thread"""
 
         opening_post = self._create_post()
 
         for i in range(2):
             Post.objects.create_post('title', 'text',
                                      thread=opening_post.get_thread())
 
         thread = opening_post.get_thread()
 
         self.assertEqual(3, thread.get_replies().count())
 
     def test_create_post_with_tag(self):
         """Test adding tag to post"""
 
-        tag = Tag.objects.create(name='test_tag')
+        tag, created = Tag.objects.get_or_create_with_alias(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
 
         thread = post.get_thread()
         self.assertIsNotNone(post, 'Post not created')
         self.assertTrue(tag in thread.tags.all(), 'Tag not added to thread')
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.get_int('View', 'ThreadsPerPage') * 2):
             self._create_post()
 
         all_threads = Thread.objects.exclude(status=STATUS_ARCHIVE)
 
         paginator = Paginator(Thread.objects.exclude(status=STATUS_ARCHIVE),
                               settings.get_int('View', 'ThreadsPerPage'))
         posts_in_second_page = paginator.page(2).object_list
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.get_int('View', 'ThreadsPerPage')].id,
                          first_post.id)
 
     def test_reflinks(self):
         """
         Tests that reflinks are parsed within post and connecting replies
         to the replied posts.
 
         Local reflink example: [post]123[/post]
         Global reflink example: [post]key_type::key::123[/post]
         """
 
         key = KeyPair.objects.generate_key(primary=True)
 
-        tag = Tag.objects.create(name='test_tag')
+        tag, created = Tag.objects.get_or_create_with_alias(name='test_tag')
 
         post = Post.objects.create_post(title='', text='', tags=[tag])
         post_local_reflink = Post.objects.create_post(title='',
                 text='[post]%d[/post]' % post.id, thread=post.get_thread())
 
         self.assertTrue(post_local_reflink in post.referenced_posts.all(),
             'Local reflink not connecting posts.')
 
 
     def test_thread_replies(self):
         """
         Tests that the replies can be queried from a thread in all possible
         ways.
         """
 
-        tag = Tag.objects.create(name='test_tag')
+        tag, created = Tag.objects.get_or_create_with_alias(name='test_tag')
         opening_post = Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
         thread = opening_post.get_thread()
 
         Post.objects.create_post(title='title', text='text', thread=thread)
         Post.objects.create_post(title='title', text='text', thread=thread)
 
         replies = thread.get_replies()
         self.assertTrue(len(replies) > 0, 'No replies found for thread.')
 
         replies = thread.get_replies(view_fields_only=True)
         self.assertTrue(len(replies) > 0,
                 'No replies found for thread with view fields only.')
 
     def test_bumplimit(self):
         """
         Tests that the thread bumpable status is changed and post uids and
         last update times are updated across all post threads.
         """
 
         op1 = Post.objects.create_post(title='title', text='text')
 
         thread1 = op1.get_thread()
         thread1.max_posts = 5
         thread1.save()
 
         uid_1 = op1.uid
 
         # Create multi reply
         Post.objects.create_post(
             title='title', text='text', thread=thread1)
         for i in range(6):
             Post.objects.create_post(title='title', text='text',
                                      thread=thread1)
 
         self.assertFalse(op1.get_thread().can_bump(),
                          'Thread is bumpable when it should not be.')
         self.assertNotEqual(
             uid_1, Post.objects.get(id=op1.id).uid,
             'UID of the first OP should be changed but it is not.')

boards/tests/test_sync.py

@@ -1,253 +1,253 b''
 from django.test import TestCase
 
 from boards.models import KeyPair, Post, Tag
 from boards.models.post.sync import SyncManager
 from boards.tests.mocks import MockRequest
 from boards.views.sync import response_get, response_list
 
 __author__ = 'neko259'
 
 
 class SyncTest(TestCase):
     def test_get(self):
         """
         Forms a GET request of a post and checks the response.
         """
 
         key = KeyPair.objects.generate_key(primary=True)
-        tag = Tag.objects.create(name='tag1')
+        tag, created = Tag.objects.get_or_create_with_alias(name='tag1')
         post = Post.objects.create_post(title='test_title',
                                         text='test_text\rline two',
                                         tags=[tag])
 
         request = MockRequest()
         request.body = (
             '<request type="get" version="1.0">'
             '<model name="post" version="1.0">'
             '<id key="%s" local-id="%d" type="%s" />'
             '</model>'
             '</request>' % (post.global_id.key,
                             post.id,
                             post.global_id.key_type)
         )
 
         response = response_get(request).content.decode()
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model name="post">'
             '<content>'
             '<id key="%s" local-id="%d" type="%s" />'
             '<title>%s</title>'
             '<text>%s</text>'
             '<tags><tag>%s</tag></tags>'
             '<pub-time>%s</pub-time>'
             '<version>%s</version>'
             '</content>' % (
                 post.global_id.key,
                 post.global_id.local_id,
                 post.global_id.key_type,
                 post.title,
                 post.get_sync_text(),
-                post.get_thread().get_tags().first().name,
+                post.get_thread().get_tags().first().get_name(),
                 post.get_pub_time_str(),
                 post.version,
             ) in response,
             'Wrong response generated for the GET request.')
 
         post.delete()
         key.delete()
 
         KeyPair.objects.generate_key(primary=True)
 
         SyncManager.parse_response_get(response, None)
         self.assertEqual(1, Post.objects.count(),
                          'Post was not created from XML response.')
 
         parsed_post = Post.objects.first()
         self.assertEqual('tag1',
-                         parsed_post.get_thread().get_tags().first().name,
+                         parsed_post.get_thread().get_tags().first().get_name(),
                          'Invalid tag was parsed.')
 
         SyncManager.parse_response_get(response, None)
         self.assertEqual(1, Post.objects.count(),
                          'The same post was imported twice.')
 
         self.assertEqual(1, parsed_post.global_id.signature_set.count(),
                          'Signature was not saved.')
 
         post = parsed_post
 
         # Trying to sync the same once more
         response = response_get(request).content.decode()
 
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model name="post">'
             '<content>'
             '<id key="%s" local-id="%d" type="%s" />'
             '<title>%s</title>'
             '<text>%s</text>'
             '<tags><tag>%s</tag></tags>'
             '<pub-time>%s</pub-time>'
             '<version>%s</version>'
             '</content>' % (
                 post.global_id.key,
                 post.global_id.local_id,
                 post.global_id.key_type,
                 post.title,
                 post.get_sync_text(),
-                post.get_thread().get_tags().first().name,
+                post.get_thread().get_tags().first().get_name(),
                 post.get_pub_time_str(),
                 post.version,
             ) in response,
             'Wrong response generated for the GET request.')
 
     def test_list_all(self):
         key = KeyPair.objects.generate_key(primary=True)
-        tag = Tag.objects.create(name='tag1')
+        tag, created = Tag.objects.get_or_create_with_alias(name='tag1')
         post = Post.objects.create_post(title='test_title',
                                         text='test_text\rline two',
                                         tags=[tag])
         post2 = Post.objects.create_post(title='test title 2',
                                          text='test text 2',
                                          tags=[tag])
 
         request_all = MockRequest()
         request_all.body = (
             '<request type="list" version="1.0">'
             '<model name="post" version="1.0">'
             '</model>'
             '</request>'
         )
 
         response_all = response_list(request_all).content.decode()
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model>'
             '<id key="{}" local-id="{}" type="{}" />'
             '<version>{}</version>'
             '</model>'
             '<model>'
             '<id key="{}" local-id="{}" type="{}" />'
             '<version>{}</version>'
             '</model>'
             '</models>'.format(
                 post.global_id.key,
                 post.global_id.local_id,
                 post.global_id.key_type,
                 post.version,
                 post2.global_id.key,
                 post2.global_id.local_id,
                 post2.global_id.key_type,
                 post2.version,
             ) in response_all,
             'Wrong response generated for the LIST request for all posts.')
 
     def test_list_existing_thread(self):
         key = KeyPair.objects.generate_key(primary=True)
-        tag = Tag.objects.create(name='tag1')
+        tag, created = Tag.objects.get_or_create_with_alias(name='tag1')
         post = Post.objects.create_post(title='test_title',
                                         text='test_text\rline two',
                                         tags=[tag])
         post2 = Post.objects.create_post(title='test title 2',
                                          text='test text 2',
                                          tags=[tag])
 
         request_thread = MockRequest()
         request_thread.body = (
             '<request type="list" version="1.0">'
             '<model name="post" version="1.0">'
             '<thread>{}</thread>'
             '</model>'
             '</request>'.format(
                 post.id,
             )
         )
 
         response_thread = response_list(request_thread).content.decode()
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model>'
             '<id key="{}" local-id="{}" type="{}" />'
             '<version>{}</version>'
             '</model>'
             '</models>'.format(
                 post.global_id.key,
                 post.global_id.local_id,
                 post.global_id.key_type,
                 post.version,
             ) in response_thread,
             'Wrong response generated for the LIST request for posts of '
             'existing thread.')
 
     def test_list_non_existing_thread(self):
         key = KeyPair.objects.generate_key(primary=True)
-        tag = Tag.objects.create(name='tag1')
+        tag, created = Tag.objects.get_or_create_with_alias(name='tag1')
         post = Post.objects.create_post(title='test_title',
                                         text='test_text\rline two',
                                         tags=[tag])
         post2 = Post.objects.create_post(title='test title 2',
                                          text='test text 2',
                                          tags=[tag])
 
         request_thread = MockRequest()
         request_thread.body = (
             '<request type="list" version="1.0">'
             '<model name="post" version="1.0">'
             '<thread>{}</thread>'
             '</model>'
             '</request>'.format(
                 0,
             )
         )
 
         response_thread = response_list(request_thread).content.decode()
         self.assertTrue(
             '<status>success</status>'
             '<models />'
             in response_thread,
             'Wrong response generated for the LIST request for posts of '
             'non-existing thread.')
 
     def test_list_pub_time(self):
         key = KeyPair.objects.generate_key(primary=True)
-        tag = Tag.objects.create(name='tag1')
+        tag, created = Tag.objects.get_or_create_with_alias(name='tag1')
         post = Post.objects.create_post(title='test_title',
                                         text='test_text\rline two',
                                         tags=[tag])
         post2 = Post.objects.create_post(title='test title 2',
                                          text='test text 2',
                                          tags=[tag])
 
         request_thread = MockRequest()
         request_thread.body = (
             '<request type="list" version="1.0">'
             '<model name="post" version="1.0">'
             '<timestamp_from>{}</timestamp_from>'
             '</model>'
             '</request>'.format(
                 post.pub_time,
             )
         )
 
         response_thread = response_list(request_thread).content.decode()
         self.assertTrue(
             '<status>success</status>'
             '<models>'
             '<model>'
             '<id key="{}" local-id="{}" type="{}" />'
             '<version>{}</version>'
             '</model>'
             '</models>'.format(
                 post2.global_id.key,
                 post2.global_id.local_id,
                 post2.global_id.key_type,
                 post2.version,
             ) in response_thread,
             'Wrong response generated for the LIST request for posts of '
             'existing thread.')