Fixed getting posts for a thread. Implemented thread getting test.

boards/models.py

@@ -1,91 +1,94 b''
 from django.db import models
 from django.http import Http404
 from django.utils import timezone
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 DIR_IMAGES = 'images'
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image = None, parent_id = NO_PARENT,
                     ip = NO_IP):
         post = self.create(title = title,
             text = text,
             pub_time = timezone.now(),
             parent = parent_id,
             image = image,
             poster_ip = ip,
             poster_user_agent = UNKNOWN_UA)
 
         return post
 
     def delete_post(self, post):
         children = self.filter(parent = post.id)
         for child in children:
             self.delete_post(child)
         post.delete()
 
     def delete_posts_by_ip(self, ip):
         posts = self.filter(poster_ip = ip)
         for post in posts:
             self.delete_post(post)
 
     def get_threads(self, tag = None):
         if tag is None:
             threads = self.filter(parent = NO_PARENT)
         else:
             threads = self.filter(parent = NO_PARENT, tag = tag)
 
         return threads
 
     def get_thread(self, opening_post_id):
-        opening_post = self.get(opening_post_id)
+        opening_post = self.get(id = opening_post_id)
         replies =  self.filter(parent = opening_post_id)
 
-        return [opening_post, replies]
+        thread = [opening_post]
+        thread.extend(replies)
+
+        return thread
 
     def exists(self, post_id):
         posts = self.filter(id = post_id)
 
         return len(posts) > 0
 
 
 class Tag(models.Model):
     """
     A tag is a text node assigned to the post. The tag serves as a board
     section. There can be multiple tags for each message
     """
 
     name = models.CharField(max_length = 100)
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     title = models.CharField(max_length = 100)
     pub_time = models.DateTimeField()
     text = models.TextField()
     image = models.ImageField(upload_to = DIR_IMAGES, blank = True)
     poster_ip = models.IPAddressField()
     poster_user_agent = models.TextField()
     parent = models.BigIntegerField()
     tags = models.ManyToManyField(Tag)
 
     def __unicode__(self):
         return self.title + ' (' + self.text + ')'
 
 
 class Admin(models.Model):
     """
     Model for admin users
     """
     name = models.CharField(max_length = 100)
     password = models.CharField(max_length = 100)
 
     def __unicode__(self):
         return self.name + '/' + '*' * len(self.password)
 

boards/tests.py

@@ -1,88 +1,99 b''
 from django.utils.unittest import TestCase
 from django.test.client import Client
 
 import boards
 
 from boards.models import Post, Admin
 
 
 class BoardTests(TestCase):
     
     def _create_post(self):
         return Post.objects.create_post(title = 'title',
             text = 'text')
 
     def test_post_add(self):
         post = self._create_post()
 	
         self.assertIsNotNone(post)
         self.assertEqual(boards.models.NO_PARENT, post.parent)
 
     def test_delete_post(self):
         post = self._create_post()
         post_id = post.id
 	
         Post.objects.delete_post(post)
 
         self.assertFalse(Post.objects.exists(post_id))
 
     def test_delete_posts_by_ip(self):
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.exists(post_id))
 
     # Authentication tests
 
     def _create_test_user(self):
         admin = Admin(name = 'test_username12313584353165',
             password = 'test_userpassword135135512')
 
         admin.save()
         return admin
 
     def test_admin_login(self):
         client = Client()
 
         self.assertFalse('admin' in client.session)
 
         admin = self._create_test_user()
 
         response = client.post('/boards/login',
             {'name': admin.name, 'password': admin.password})
 
         # it means that login passed and user are redirected to another page
         self.assertEqual(302, response.status_code)
 
         self.assertTrue('admin' in client.session)
         self.assertTrue(client.session['admin'])
 
         admin.delete()
 
         wrong_name = 'sd2f1s3d21fs3d21f'
         wrong_password = 'sd2f1s3d21fs3d21fsdfsd'
 
         client.post('/boards/login', {'name': wrong_name, 'password': wrong_password})
         self.assertFalse(client.session['admin'])
 
     def test_admin_logout(self):
         client = Client()
 
 
         self.assertFalse('admin' in client.session)
 
         admin = self._create_test_user()
 
         client.post('/boards/login',
             {'name': admin.name, 'password': admin.password})
 
         self.assertTrue(client.session['admin'])
 
         client.get('/boards/logout')
 
         self.assertFalse(client.session['admin'])
 
         admin.delete()
 
+    def test_get_thread(self):
+        opening_post = self._create_post()
+        op_id = opening_post.id
+
+        for i in range(0, 2):
+            Post.objects.create_post('title', 'text',
+                parent_id = op_id)
+
+        thread = Post.objects.get_thread(op_id)
+
+        self.assertEqual(3, thread.__len__())

boards/urls.py

@@ -1,21 +1,21 b''
 from django.conf.urls import patterns, url
 from boards import views
 
 urlpatterns = patterns('',
 
     # /boards/
     url(r'^$', views.index, name = 'index'),
 
     # login page
     url(r'^login$', views.login, name='login'),
     # logout page
     url(r'^logout$', views.logout, name='logout'),
 
     # /boards/tag/
-    url(r'^(?P<tag>\w+)/$', views.tag, name = 'tag'),
+    url(r'^tag/(?P<tag>\w+)/$', views.tag, name = 'tag'),
     # /boards/post_id/
-    url(r'^(?P<post>\w+)/$', views.thread, name = 'thread'),
+    url(r'^post/(?P<id>\w+)/$', views.thread, name = 'thread'),
     # /boards/tag/post/
     url(r'^post.html$', views.new_post,
 	    name='post'),
 )

boards/views.py

@@ -1,86 +1,85 b''
 from django.template import RequestContext
 from boards import forms
 from boards.models import Post, Admin
 from django.shortcuts import render, get_list_or_404
 from django.http import HttpResponseRedirect, Http404
 
 def index(request):
     context = RequestContext(request)
 
     if request.method == 'POST':
         Post.objects.create_post(request.POST['title'],
             request.POST['text'], ip = request.META['REMOTE_ADDR'])
 
     threads = Post.objects.get_threads()
 
     context['threads'] = None if len(threads) == 0 else threads
     context['form'] = forms.NewThreadForm()
 
     return render(request, 'posting_general.html',
         context)
 
 def new_post(request):
     """Add a new post (in thread or as a reply)."""
 
     title = request.POST['title']
     text = request.POST['text']
 
     image = request.POST['image']
 
     # TODO Get tags list, download image (if link is given)
 
     post = Post.objects.create_post(title = title, text = text, image = image)
 
     # TODO Show the thread with a newly created post
 
 def tag(request):
     """Get all tag threads (posts without a parent)."""
 
     tag_name = request.GET['tag']
 
     threads = get_list_or_404(Post, tag = tag_name)
 
     context = RequestContext(request)
     context['threads'] = None if len(threads) == 0 else threads
     context['tag'] = tag_name
 
     return render(request, 'posting_general.html',
         context)
 
-def thread(request):
+def thread(request, id):
     """Get all thread posts"""
 
     # TODO Show 404 if there is no such thread
 
-    opening_post_id = request.GET['id']
-    posts = Post.objects.get_thread(opening_post_id)
+    posts = Post.objects.get_thread(id)
 
     context = RequestContext(request)
     context['posts'] = posts
 
-    return render(request), 'thread.html'
+    return render(request, 'thread.html', context)
 
 def login(request):
     """Log in as admin"""
 
     if 'name' in request.POST and 'password' in request.POST:
         request.session['admin'] = False
 
         isAdmin = len(Admin.objects.filter(name = request.POST['name'],
             password = request.POST['password'])) > 0
 
         if isAdmin :
             request.session['admin'] = True
 
             response = HttpResponseRedirect('/boards')
 
         else:
             response = render(request, 'login.html', {'error' : 'Login error'})
     else:
         response = render(request, 'login.html', {})
 
     return response
 
 def logout(request):
     request.session['admin'] = False
     return HttpResponseRedirect('/boards')

templates/posting_general.html

@@ -1,27 +1,28 b''
 {% extends "base.html" %}
 
 {% block content %}
 
 	{% if threads %}
 		{% for thread in threads %}
             <span class="title">{{ thread.title }}</span><br />
             <span class="text">{{ thread.text }}</span><br />
-            <a class="link" href="/boards/id/{{ thread.id }}/">View thread</a>
+            <a class="link" href="/boards/post/{{ thread.id }}/">View
+                thread</a>
             <hr />
 		{% endfor %}
 	{% else %}
 		No threads found.
         <hr />
 	{% endif %}
 
     <div class="post-form">
     <form action="/boards/" method="post">{% csrf_token %}
 		{{ form.as_p }}
 		<input type="submit" value="Post!" />
 	</form>
     </div>
 
 	<HR />
 
 {% endblock %}