Fixed tests to use the new settings

boards/tests/test_post.py

@@ -1,135 +1,135 b''
 from django.core.paginator import Paginator
 from django.test import TestCase
 from boards import settings
 from boards.models import Tag, Post, Thread
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         tag, created = Tag.objects.get_or_create(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,
                          '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')
         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_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
-        for i in range(settings.MAX_THREAD_COUNT + 1):
+        for i in range(settings.get_int('Messages', 'MaxThreadCount') + 1):
             self._create_post()
 
-        self.assertEqual(settings.MAX_THREAD_COUNT,
+        self.assertEqual(settings.get_int('Messages', 'MaxThreadCount'),
                          len(Thread.objects.filter(archived=False)))
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
-        for i in range(settings.MAX_THREAD_COUNT):
+        for i in range(settings.get_int('Messages', 'MaxThreadCount')):
             self._create_post()
 
         all_threads = Thread.objects.filter(archived=False)
 
         paginator = Paginator(Thread.objects.filter(archived=False),
-                              settings.THREADS_PER_PAGE)
+                              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.THREADS_PER_PAGE].id,
+        self.assertEqual(all_threads[settings.get_int('View', 'ThreadsPerPage')].id,
                          first_post.id)
 
     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')
         opening_post = Post.objects.create_post(title='title', text='text',
                                         tags=[tag])
         thread = opening_post.get_thread()
 
         reply1 = Post.objects.create_post(title='title', text='text', thread=thread)
         reply2 = 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.')