karmaworld/apps/users/tests.py

   1 #!/usr/bin/env python
   2 # -*- coding:utf8 -*-
   3 # Copyright (C) 2013  FinalsClub Foundation
   4 import datetime
   5 from django.contrib.sessions.backends.db import SessionStore
   6 from django.core.exceptions import ObjectDoesNotExist
   7 from django.http import HttpRequest
   8 from django.test import TestCase
   9
  10 from django.contrib.auth.models import User
  11 from karmaworld.apps.courses.views import flag_course
  12 from karmaworld.apps.notes.models import Note
  13 from karmaworld.apps.courses.models import Course
  14 from karmaworld.apps.courses.models import School
  15 from karmaworld.apps.notes.views import thank_note, flag_note, downloaded_note
  16 from karmaworld.apps.users.models import NoteKarmaEvent, GenericKarmaEvent, CourseKarmaEvent, give_email_confirm_karma
  17
  18
  19 class TestUsers(TestCase):
  20
  21     def setUp(self):
  22         # create base values to test db representations
  23         self.now = datetime.datetime.utcnow()
  24
  25         # create a school to satisfy course requirements
  26         self.school = School()
  27         self.school.name = 'Marshall College'
  28         self.school.save()
  29
  30         # create a course to test relationships
  31         self.course = Course()
  32         self.course.school = self.school
  33         self.course.name = u'Archaeology 101'
  34         self.course.save()
  35         # override Course.save() appending an ID to the slug
  36         self.course.slug = u'archaeology-101'
  37         self.course.save()
  38
  39         self.user1 = User(username='Alice')
  40         self.user1.save()
  41
  42         self.user2 = User(username='Bob')
  43         self.user2.save()
  44
  45         # create a note to test against
  46         self.note = Note()
  47         self.note.course = self.course
  48         self.note.name = u"Lecture notes concerning the use of therefore ∴"
  49         self.note.text = "This is the plaintext version of a note. It's pretty cool."
  50         self.note.user = self.user1
  51         self.note.save()
  52
  53         self.request1 = HttpRequest()
  54         self.request1.user = self.user1
  55         self.request1.method = 'POST'
  56         self.request1.META = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
  57         self.request1.session = SessionStore()
  58
  59         self.request2 = HttpRequest()
  60         self.request2.user = self.user2
  61         self.request2.method = 'POST'
  62         self.request2.META = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
  63         self.request2.session = SessionStore()
  64
  65     def test_thank_own_note_karma(self):
  66         """Make sure you don't get karma for thanking your own note"""
  67         thank_note(self.request1, self.note.pk)
  68         try:
  69             NoteKarmaEvent.objects.get(note=self.note)
  70             self.fail("You can't thank your own note")
  71         except ObjectDoesNotExist:
  72             pass
  73
  74     def test_thank_anothers_note_karma(self):
  75         """Get karma for having your note thanked"""
  76         thank_note(self.request2, self.note.pk)
  77         try:
  78             NoteKarmaEvent.objects.get(note=self.note)
  79         except ObjectDoesNotExist:
  80             self.fail("Karma event not created")
  81
  82     def test_note_deleted_karma(self):
  83         """Lose karma if your note is deleted"""
  84         thank_note(self.request2, self.note.pk)
  85         self.note.delete()
  86         try:
  87             GenericKarmaEvent.objects.get(event_type=GenericKarmaEvent.NOTE_DELETED)
  88         except ObjectDoesNotExist:
  89             self.fail("Karma event not created")
  90         try:
  91             NoteKarmaEvent.objects.get(note=self.note)
  92             self.fail("Karma event not deleted")
  93         except ObjectDoesNotExist:
  94             pass
  95
  96     def test_note_give_flag_karma(self):
  97         """Lose karma for flagging a note"""
  98         flag_note(self.request2, self.note.pk)
  99         try:
 100             NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.GIVE_FLAG, user=self.user2)
 101         except ObjectDoesNotExist:
 102             self.fail("Karma event not created")
 103
 104     def test_course_give_flag_karma(self):
 105         """Lose karma for flagging a course"""
 106         flag_course(self.request2, self.course.pk)
 107         try:
 108             CourseKarmaEvent.objects.get(event_type=CourseKarmaEvent.GIVE_FLAG, user=self.user2)
 109         except ObjectDoesNotExist:
 110             self.fail("Karma event not created")
 111
 112     def test_note_get_flagged_karma(self):
 113         """Lose karma for having your note flagged many times"""
 114         flag_note(self.request2, self.note.pk)
 115         flag_note(self.request2, self.note.pk)
 116         flag_note(self.request2, self.note.pk)
 117         flag_note(self.request2, self.note.pk)
 118         flag_note(self.request2, self.note.pk)
 119         flag_note(self.request2, self.note.pk)
 120         try:
 121             NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.GET_FLAGGED, user=self.user1)
 122         except ObjectDoesNotExist:
 123             self.fail("Karma event not created")
 124
 125     def test_note_download_karma(self):
 126         """You lose karma for downloading a note, person who uploaded it gains karma"""
 127         downloaded_note(self.request2, self.note.pk)
 128         try:
 129             NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.DOWNLOADED_NOTE, user=self.user2)
 130         except ObjectDoesNotExist:
 131             self.fail("Karma event not created")
 132         try:
 133             NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.HAD_NOTE_DOWNLOADED, user=self.user1)
 134         except ObjectDoesNotExist:
 135             self.fail("Karma event not created")
 136
 137     def test_download_own_note_karma(self):
 138         """No karma change for downloading your own note"""
 139         downloaded_note(self.request1, self.note.pk)
 140         try:
 141             NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.DOWNLOADED_NOTE, user=self.user1)
 142             self.fail("Karma debited for downloading own note, but shouldn't have been.")
 143         except ObjectDoesNotExist:
 144             pass
 145         try:
 146             NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.HAD_NOTE_DOWNLOADED, user=self.user1)
 147             self.fail("Karma given for downloading own note, but shouldn't have been.")
 148         except ObjectDoesNotExist:
 149             pass
 150
 151     def test_email_confirm_karma(self):
 152         class FakeEmailAddress:
 153             user = self.user1
 154             email = self.user1.email
 155
 156         give_email_confirm_karma(None, email_address=FakeEmailAddress())
 157         try:
 158             GenericKarmaEvent.objects.get(event_type=GenericKarmaEvent.EMAIL_CONFIRMED, user=self.user1)
 159         except ObjectDoesNotExist:
 160             self.fail("Karma event not created")