finish adding tests

Author: baloncek2662

irc/tests.py

@@ -23,25 +23,25 @@
     ('O', 'Other'),
 )
 
-def send_wrong_request(self, path):
-    """
-    Tests that the method, the path of which is passed as a parameter to this function, responds with NO if:
-    1) the http method is not POST
-    2) the http method is POST, but TOKEN is not passed
-    3) the http method is POST, but the passed TOKEN is wrong
-    """
-    url = "/irc/%s" %path
-
-    response = self.client.get(url)
-    self.assertContains(response, 'NO')
+class IrcViewTests(TestCase):
+    def send_wrong_requests(self, path):
+        """
+        Tests that the method, the path of which is passed as a parameter to this function, responds with NO if:
+        1) the http method is not POST
+        2) the http method is POST, but TOKEN is not passed
+        3) the http method is POST, but the passed TOKEN is wrong
+        """
+        url = "/irc/%s" %path
 
-    response = self.client.post(url)
-    self.assertContains(response, 'NO')
+        response = self.client.get(url)
+        self.assertContains(response, 'NO')
 
-    response = self.client.post(url, {'token': 'wrongtoken'})
-    self.assertContains(response, 'NO')
+        response = self.client.post(url)
+        self.assertContains(response, 'NO')
 
-class IrcViewTests(TestCase):
+        response = self.client.post(url, {'token': 'wrongtoken'})
+        self.assertContains(response, 'NO')
+    
     def test_login_loads_correctly(self):
         """
         Tests that the login page loads correctly
@@ -73,57 +73,112 @@ def test_irc(self):
     def test_irc_bot_add(self):
         """
         Tests that the irc_bot_add method responds with OK if the correct TOKEN is passed, along with channel and raw
-        Also tests that the response is NO when we send wrong requests through the send_wrong_request function
+        Also tests that the response is NO when we send wrong requests through the send_wrong_requests function
         """
         response = self.client.post('/irc/add', {'token': 'enter', 'raw': ':nick!name@address PRIVMSG #test :Hello!', 'channel': '#psywerx'})
         self.assertContains(response, 'OK')
 
-        send_wrong_request(self, 'add')
+        self.send_wrong_requests('add')
 
     @patch('irc.views.TOKEN', 'enter')
     def test_karma_add(self):
         """
         Tests that the karma_add method responds with OK if the correct TOKEN is passed, along with channel and nick
-        Also tests that the response is NO when we send wrong requests through the send_wrong_request function
+        Also tests that the response is NO when we send wrong requests through the send_wrong_requests function
         """
         response = self.client.post('/irc/karma', {'token': 'enter', 'nick': 'nickname', 'channel': '#psywerx'})
         self.assertContains(response, 'OK')
 
-        send_wrong_request(self, 'karma')
+        self.send_wrong_requests('karma')
 
     @patch('irc.views.TOKEN', 'enter')
     def test_karma_nick(self):
         """
-        Only runs through the method
+        Tests that the karma_nick method returns the user's karma or all karma numbers if no nick is passed
+        Also tests that the response is NO when we send wrong requests through the send_wrong_requests function
         """
-        #has nick
-        self.client.post('/irc/karma_nick', {'token': 'enter', 'nick': 'name', 'channel': '#psywerx'})
-        #doesn't have nick
-        self.client.post('/irc/karma_nick', {'token': 'enter', 'channel': '#psywerx'})
-
-        send_wrong_request(self, 'karma_nick')    
+        #user gets 2 karma with their first nick
+        self.client.post('/irc/karma', {'token': 'enter', 'nick': 'name', 'channel': '#psywerx'})
+        self.client.post('/irc/karma', {'token': 'enter', 'nick': 'name', 'channel': '#psywerx'})
+        response = self.client.post('/irc/karma_nick', {'token': 'enter', 'nick': 'name', 'channel': '#psywerx'})
+        self.assertEquals(response.content, '2')
+        
+        #user additionally gets 1 karma with their other nick
+        self.client.post('/irc/karma', {'token': 'enter', 'nick': 'nameOther', 'channel': '#psywerx'})
+        response = self.client.post('/irc/karma_nick', {'token': 'enter', 'nick': 'name', 'channel': '#psywerx'})
+        expected_message = '2 (or 3 with his other nicknames - nameOther)'
+        self.assertEquals(response.content, expected_message)
+
+        #no nick is posted
+        response = self.client.post('/irc/karma_nick', {'token': 'enter', 'channel': '#psywerx'})
+        expected_message = '[{"nick": "name", "karma": 3}]' 
+        self.assertEquals(response.content, expected_message)
+
+        self.send_wrong_requests('karma_nick')    
 
     @patch('irc.views.TOKEN', 'enter')
     def test_join(self):
         """
-        Tests that the join method responds with ok if the correct TOKEN is passed, along with nick, group, offline and channel
-        Also tests that the response is NO when we send wrong requests through the send_wrong_request function
+        Tests that the join method responds with ok and a GroupMembers object is created if the correct TOKEN is passed 
+        Also tests that the response is NO when we send wrong requests through the send_wrong_requests function
         """
         response = self.client.post('/irc/join', {'token': 'enter', 'nick': 'name', 'group': 'Psywerx', 'offline': 'false', 'channel': '#psywerx'})
         self.assertContains(response, 'ok')
+        self.assertTrue(GroupMembers.objects.all().exists())
 
-        send_wrong_request(self, 'join')
+        members_set = set((gm.nick, gm.group, gm.channel) for gm in GroupMembers.objects.all())
+        member_params = ('name', 'Psywerx', '#psywerx')
+        self.assertIn(member_params, members_set)
+
+        self.send_wrong_requests('join')
 
     @patch('irc.views.TOKEN', 'enter')
     def test_leave(self):
         """
-        Tests that the leave method responds with ok if the correct TOKEN is passed, along with nick, group, offline and channel
-        Also tests that the response is NO when we send wrong requests through the send_wrong_request function
+        Tests that the leave method responds with ok and the corresponding object is deleted if the correct TOKEN is passed
+        Also tests that the response is NO when we send wrong requests through the send_wrong_requests function
         """
+        self.client.post('/irc/join', {'token': 'enter', 'nick': 'name', 'group': 'Psywerx', 'offline': 'false', 'channel': '#psywerx'})
+        # some other person leaves - GroupMembers object exists
+        self.client.post('/irc/leave', {'token': 'enter', 'nick': 'falseName', 'group': 'Psywerx', 'channel': '#psywerx'})
+        self.assertTrue(GroupMembers.objects.all().exists())
+        # the joined user leaves - GroupMembers object doesn't exist anymore
         response = self.client.post('/irc/leave', {'token': 'enter', 'nick': 'name', 'group': 'Psywerx', 'channel': '#psywerx'})
+        self.assertFalse(GroupMembers.objects.all().exists())
         self.assertContains(response, 'ok')
 
-        send_wrong_request(self, 'leave')
+        self.send_wrong_requests('leave')
+
+    @patch('irc.views.TOKEN', 'enter')
+    def test_leave_all(self):
+        """
+        Tests that the leaveAll method responds with ok and all the GroupMembers objects with the matching name and 
+        channel are deleted if the correct TOKEN is passed
+        Also tests that the response is NO when we send wrong requests through the send_wrong_requests function
+        """
+        self.client.post('/irc/join', {'token': 'enter', 'nick': 'name', 'group': 'Psywerx', 'offline': 'false', 'channel': '#psywerx'})
+        self.client.post('/irc/join', {'token': 'enter', 'nick': 'name', 'group': 'PsywerxTwo', 'offline': 'false', 'channel': '#psywerx'})
+        response = self.client.post('/irc/leaveAll', {'token': 'enter', 'nick': 'name', 'channel': '#psywerx'})
+        self.assertContains(response, 'ok')
+        self.assertFalse(GroupMembers.objects.all().exists())
+
+        self.send_wrong_requests('leaveAll')
+
+    @patch('irc.views.TOKEN', 'enter')
+    def test_mention(self):
+        """
+        Tests that the mention method returns all the members in the group
+        Also tests that the response is NO when we send wrong requests through the send_wrong_requests function
+        """
+        self.client.post('/irc/join', {'token': 'enter', 'nick': 'name', 'group': 'Psywerx', 'offline': 'false', 'channel': '#psywerx'})
+        self.client.post('/irc/join', {'token': 'enter', 'nick': 'nameTwo', 'group': 'Psywerx', 'offline': 'false', 'channel': '#psywerx'})
+        response = self.client.post('/irc/mention', {'token': 'enter', 'group': 'Psywerx', 'channel': '#psywerx'})
+        
+        expected_list = '[["name", "#psywerx", false], ["nameTwo", "#psywerx", false]]'
+        self.assertEquals(expected_list, response.content)
+
+        self.send_wrong_requests('mention')
+        
 
 class IrcModelsTests(TestCase):
     fixtures = ['messages.json']
@@ -169,7 +224,7 @@ def test_msg_types_changed(self):
 
     def test_parse_method(self):
         """
-        Tests every if/else statement in class Irc, method parse(see comments)
+        Tests every if/else statement in the parse method of class Irc
         """
         instance = Irc()
         channel = 'channel'
@@ -221,7 +276,16 @@ def test_parse_method(self):
         #tests response if message has a link in it
         raw = ':nick!name@address TOPIC #test :https://www.youtube.com/'
         self.assertEquals(instance.parse(raw, channel), response)
-        self.assertIn('https://www.youtube.com/', Link.objects.all().__str__())
+        links_set = set(l.link for l in Link.objects.all())
+        links_params = ('https://www.youtube.com/')
+        self.assertIn(links_params, links_set)
+        self.assertFalse(Repost.objects.all().exists())
+
+        #tests response if message contains a link that had been posted before - a Repost object is created
+        raw = ':nick!name@address TOPIC #test :https://www.youtube.com/'
+        response = u'REPOST nick nick T 1'
+        self.assertEquals(instance.parse(raw, channel), response)
+        self.assertTrue(Repost.objects.all().exists())
 
     def test_join_leave_methods(self):
         """
@@ -235,11 +299,12 @@ def test_join_leave_methods(self):
         instance.join(first_user.nick, first_user.group, first_user.offline, first_user.channel)
         instance.join(second_user.nick, second_user.group, second_user.offline, second_user.channel)
 
-        group_members_objects = GroupMembers.objects.all()
-        first_user_parameters = '{0} {1} {2}'.format(first_user.nick, first_user.group, first_user.channel)
-        second_user_parameters = '{0} {1} {2}'.format(second_user.nick, second_user.group, second_user.channel)
-        self.assertIn(first_user_parameters, group_members_objects.__str__())
-        self.assertIn(second_user_parameters, group_members_objects.__str__())
+        group_members_set = set((gm.nick, gm.group, gm.channel) for gm in GroupMembers.objects.all())
+        first_user_params = (first_user.nick, first_user.group, first_user.channel)
+        self.assertIn(first_user_params, group_members_set)
+        second_user_params = (second_user.nick, second_user.group, second_user.channel)
+        self.assertIn(second_user_params, group_members_set)
 
         instance.leave(second_user.nick, second_user.group, second_user.channel)
-        self.assertNotIn(second_user_parameters, group_members_objects.__str__())
+        group_members_set = set((gm.nick, gm.group, gm.channel) for gm in GroupMembers.objects.all())
+        self.assertNotIn(second_user_params, group_members_set)

irc/views.py

@@ -50,6 +50,8 @@ def karma_nick(request):
                 karma = len(Karma.objects.filter(nick=request.POST['nick'], channel__iexact=request.POST['channel'], time__year=datetime.now().year))
                 if combined_karma > karma:
                     karma = ("%s (or %s with his other nicknames - " + ", ".join(nicks) + ")") % (karma, combined_karma)
+                else:
+                    karma = "%s" %karma
             else:
                 d = defaultdict(int)
                 dn = {}

local_settings.py.example

@@ -15,6 +15,7 @@ DATABASES = {
 
 # Change the password you use locally to access /irc
 MAGIC_WORD = "root"
+MAGIC_WORD = hashlib.sha224(MAGIC_WORD).hexdigest()
 
 CHANNEL = "#psywerx"
 
@@ -27,5 +28,3 @@ TIME_ZONE = 'Europe/Ljubljana'
 # Language code for this installation. All choices can be found here:
 # http://www.i18nguy.com/unicode/language-identifiers.html
 LANGUAGE_CODE = 'si'
-
-MAGIC_WORD = hashlib.sha224(MAGIC_WORD).hexdigest()

web/tests.py

@@ -7,6 +7,7 @@
 
 from django.test import TestCase
 from .models import *
+from web.models import Static
 
 class SimpleTest(TestCase):
     def test_basic_addition(self):
@@ -50,4 +51,13 @@ def test_wrong_url(self):
         404.html loading
         """
         response = self.client.get('/nonexistenturl')
-        self.assertContains(response, 'The force is wrong with your url...')
+        self.assertContains(response, 'The force is wrong with your url...')
+
+    def test_site_title(self):
+        """
+        Tests that you can set a custom site title and footer
+        """
+        Static.objects.create(title='Custom Header', footer='Custom Footer')
+        response = self.client.get('/')
+        self.assertContains(response, 'Custom Header')
+        self.assertContains(response, 'Custom Footer')

web/views.py

@@ -6,7 +6,7 @@ def index(request):
     return render_to_response('index.html', context_instance=RequestContext(request))
 
 def error500(request, template_name = '500.html'):
-    return render_to_response(template_name, context_instance=RequestContext(request))
+    return render_to_response(template_name, context_instance=RequestContext(request))  # pragma: no cover 
 
 def error404(request, template_name = '404.html'):
     return render_to_response(template_name, context_instance=RequestContext(request))