duck-booking-tool/booking/tests.py

# -*- coding: utf-8 -*-
"""
Tests for the Duck Booking Tool frontend
"""

import datetime

from django.conf import settings
from django.contrib.auth.models import User
from django.test import TestCase, Client, override_settings
from django.utils import timezone

from .ducklevel import level_to_up_minutes, level_to_down_minutes, minutes_to_level
from .templatetags import booking_tags
from .models import Duck, Competence, DuckCompetence, Species, \
                    Location, Booking, DuckName, DuckNameVote
from .apps import max_level_check

class FrontTest(TestCase):
    """
    Test case for the front end
    """

    def setUp(self):
        self.client = Client()

    def test_index_page(self):
        """
        Test for the existence of the main page
        """

        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)

    def test_vocabulary_page(self):
        """
        Test for the existence of the vocabulary page
        """

        response = self.client.get('/vocabulary.html')
        self.assertEqual(response.status_code, 200)

    def test_terms_page(self):
        """
        Test for the existence of the terms page
        """

        response = self.client.get('/terms.html')
        self.assertEqual(response.status_code, 200)

    def test_disclaimer_page(self):
        """
        Test for the existence of the disclaimer page
        """

        response = self.client.get('/disclaimer.html')
        self.assertEqual(response.status_code, 200)

class DuckCompLevelTest(TestCase):
    """
    Test case for competence level calculation
    """

    def setUp(self):
        user = User.objects.create_user(username='test', password='test')

        species = Species.objects.create(name='test species')

        location = Location.objects.create(name='test location')

        duck = Duck.objects.create(species=species,
                                   location=location,
                                   donated_by=user)

        comp = Competence.objects.create(name='testing',
                                         added_by=user)

        self.duckcomp = DuckCompetence.objects.create(duck=duck,
                                                      comp=comp,
                                                      up_minutes=0,
                                                      down_minutes=0)

    def test_max_minutes(self):
        """
        Test if level can not go above settings.MAX_DUCK_LEVEL)
        """

        max_up_minutes = level_to_up_minutes(settings.MAX_DUCK_LEVEL)
        double_minutes = level_to_up_minutes(settings.MAX_DUCK_LEVEL * 2)
        max_down_minutes = level_to_down_minutes(settings.MAX_DUCK_LEVEL)

        level = minutes_to_level(max_up_minutes, 0)
        self.assertEqual(level, settings.MAX_DUCK_LEVEL)

        level = minutes_to_level(max_up_minutes + 1, 0)
        self.assertEqual(level, settings.MAX_DUCK_LEVEL)

        level = minutes_to_level(double_minutes, 0)
        self.assertEqual(level, settings.MAX_DUCK_LEVEL)

        level = minutes_to_level(0, max_down_minutes)
        self.assertEqual(level, settings.MAX_DUCK_LEVEL)

        level = minutes_to_level(0, max_down_minutes + 1)
        self.assertEqual(level, settings.MAX_DUCK_LEVEL)

    def test_conversions(self):
        """
        Test minutes to level conversations
        """

        for i in range(1, settings.MAX_DUCK_LEVEL):
            up_minutes = level_to_up_minutes(i)
            down_minutes = level_to_down_minutes(i)

            up_level = minutes_to_level(up_minutes, 0)
            down_level = minutes_to_level(0, down_minutes)

            self.assertEqual(up_level, i, msg="Test failed for value %d" % i)
            self.assertEqual(
                down_level, i,
                msg="Test failed for value %d" % i)

    def test_level_to_minutes(self):
        """
        Test level to minutes conversations
        """

        self.assertEqual(level_to_up_minutes(0), 0)
        self.assertEqual(level_to_up_minutes(1), 20)
        self.assertEqual(level_to_up_minutes(2), 200)
        self.assertEqual(level_to_up_minutes(3), 2000)
        self.assertEqual(level_to_up_minutes(4), 20000)
        self.assertEqual(level_to_up_minutes(5), 200000)

        self.assertEqual(level_to_down_minutes(0), 0)
        self.assertEqual(level_to_down_minutes(1), 200)
        self.assertEqual(level_to_down_minutes(2), 2000)
        self.assertEqual(level_to_down_minutes(3), 20000)
        self.assertEqual(level_to_down_minutes(4), 200000)
        self.assertEqual(level_to_down_minutes(5), 2000000)

    def test_no_comp(self):
        """
        Test if level equals 0 if minutes count is 0
        """

        self.duckcomp.up_minutes = 0
        self.duckcomp.down_minutes = 0
        self.assertEquals(self.duckcomp.level(), 0)

    def test_comp_levels(self):
        """
        Test competence level calculation
        """

        self.duckcomp.down_minutes = 0

        for lvl in range(1, settings.MAX_DUCK_LEVEL):
            minutes = level_to_up_minutes(lvl)
            self.duckcomp.up_minutes = minutes
            self.assertEqual(self.duckcomp.level(), lvl)

    def test_high_minutes(self):
        """
        Test duck level calculation with a very high amount of minutes
        """

        self.duckcomp.up_minutes = level_to_up_minutes(settings.MAX_DUCK_LEVEL)
        self.duckcomp.down_minutes = level_to_down_minutes(settings.MAX_DUCK_LEVEL)
        self.assertEqual(self.duckcomp.level(), settings.MAX_DUCK_LEVEL)

class DuckAgeTest(TestCase):
    """
    Tests related to duck age
    """

    def test_duck_is_from_the_future(self):
        """
        Test if the duck came from the future (ie. donation time is in
        the future)
        """

        future_duck = Duck(donated_at=timezone.now() + datetime.timedelta(days=2))
        self.assertEqual(future_duck.age(), -1)

    def test_duck_age_formatter(self):
        """
        Test duck age formatter
        """

        self.assertEqual(booking_tags.age_format("aoeu"), "aoeu")
        self.assertEqual(booking_tags.age_format(0), "a few moments")
        self.assertEqual(booking_tags.age_format(1), "1 second")
        self.assertEqual(booking_tags.age_format(2), "2 seconds")
        self.assertEqual(booking_tags.age_format(60), "1 minute")
        self.assertEqual(booking_tags.age_format(61), "1 minute 1 second")
        self.assertEqual(booking_tags.age_format(62), "1 minute 2 seconds")
        self.assertEqual(booking_tags.age_format(120), "2 minutes")
        self.assertEqual(booking_tags.age_format(3600), "1 hour")
        self.assertEqual(booking_tags.age_format(3601), "1 hour 1 second")
        self.assertEqual(booking_tags.age_format(3660), "1 hour 1 minute")
        self.assertEqual(booking_tags.age_format(3720), "1 hour 2 minutes")
        self.assertEqual(booking_tags.age_format(7200), "2 hours")
        self.assertEqual(booking_tags.age_format(86400), "1 day")
        self.assertEqual(booking_tags.age_format(86401), "1 day 1 second")
        self.assertEqual(booking_tags.age_format(86460), "1 day 1 minute")
        self.assertEqual(booking_tags.age_format(90000), "1 day 1 hour")
        self.assertEqual(booking_tags.age_format(93600), "1 day 2 hours")
        self.assertEqual(booking_tags.age_format(172800), "2 days")
        self.assertEqual(booking_tags.age_format(2592000), "1 month")
        self.assertEqual(booking_tags.age_format(2592001), "1 month 1 second")
        self.assertEqual(booking_tags.age_format(2592060), "1 month 1 minute")
        self.assertEqual(booking_tags.age_format(2595600), "1 month 1 hour")
        self.assertEqual(booking_tags.age_format(2678400), "1 month 1 day")
        self.assertEqual(booking_tags.age_format(2764800), "1 month 2 days")
        self.assertEqual(booking_tags.age_format(5184000), "2 months")
        self.assertEqual(booking_tags.age_format(31536000), "1 year")
        self.assertEqual(booking_tags.age_format(31536001), "1 year 1 second")
        self.assertEqual(booking_tags.age_format(31536060), "1 year 1 minute")
        self.assertEqual(booking_tags.age_format(31539600), "1 year 1 hour")
        self.assertEqual(booking_tags.age_format(31622400), "1 year 1 day")
        self.assertEqual(booking_tags.age_format(34128000), "1 year 1 month")
        self.assertEqual(booking_tags.age_format(36720000), "1 year 2 months")
        self.assertEqual(booking_tags.age_format(63072000), "2 years")

class BookingTimeTest(TestCase):
    """
    Test case for calculating booking time and popularity
    """

    def setUp(self):
        user = User()
        user.save()

        species = Species.objects.create(name='duck')
        location = Location.objects.create(name='start')

        self.duck1 = Duck.objects.create(species=species,
                                         location=location,
                                         donated_by=user)

        competence = Competence.objects.create(name='test',
                                               added_by=user)

        now = timezone.now()
        Booking.objects.create(duck=self.duck1,
                               start_ts=now - datetime.timedelta(days=2),
                               end_ts=now - datetime.timedelta(days=1),
                               user=user,
                               comp_req=competence)

        self.duck2 = Duck.objects.create(species=species,
                                         location=location,
                                         donated_by=user)

        Booking.objects.create(duck=self.duck2,
                               start_ts=now - datetime.timedelta(days=3),
                               end_ts=now - datetime.timedelta(days=2),
                               user=user,
                               comp_req=competence)

        Booking.objects.create(duck=self.duck2,
                               start_ts=now - datetime.timedelta(days=2),
                               end_ts=now - datetime.timedelta(days=1),
                               user=user,
                               comp_req=competence)

    def test_total_booking_time(self):
        """
        Test total booking time
        """

        self.assertEqual(259200, Booking.total_booking_time())

    def test_duck_booking_time(self):
        """
        Test duck booking time
        """

        self.assertEqual(86400, Booking.duck_booking_time(self.duck1))
        self.assertEqual(172800, Booking.duck_booking_time(self.duck2))

    def test_dpx(self):
        """
        Test Duck Popularity indeX calculation
        """

        self.assertEqual(1/3, self.duck1.dpx())
        self.assertEqual(2/3, self.duck2.dpx())

class TestListing(TestCase):
    """
    Test case for duck listing
    """

    def setUp(self):
        self.client = Client()

        species = Species.objects.create()
        loc = Location.objects.create()
        user = User.objects.create_user(username='test',
                                        password='test')

        self.duck = Duck.objects.create(species=species,
                                        location=loc,
                                        donated_by=user)

    def test_front_page(self):
        """
        Test existence of the front page
        """

        response = self.client.get('/')
        self.assertEqual(200, response.status_code)

        self.assertEqual(1, len(response.context['duck_list']))

class SimilarCompTest(TestCase):
    """
    Test case for competence name fuzzy search
    """

    def setUp(self):
        admin = User.objects.create_user(username='admin',
                                         password='test')

        competence_list = (
            'Creativity',
            'Administration',
            'Perl',
            'Python',
            'TCSH',
        )

        for competence in competence_list:
            Competence.objects.create(name=competence,
                                      added_by=admin)

    def test_good_similar_competences(self):
        """
        Test similar competence list with different inputs
        """

        comp_list = Competence.get_similar_comps('perl')
        self.assertEquals(1, len(comp_list))

        comp_list = Competence.get_similar_comps('pzthon')
        self.assertEquals(1, len(comp_list))

        comp_list = Competence.get_similar_comps(u'kreativitás')
        self.assertEqual(1, len(comp_list))

    def test_bad_similar_competence(self):
        """
        Test similar competence list with a totally new and unmatching
        competence name
        """

        comp_list = Competence.get_similar_comps('development')
        self.assertEqual(0, len(comp_list))

class BookingTest(TestCase):
    """
    Test duck booking functionality
    """

    def setUp(self):
        self.spec = Species.objects.create(name='test')
        self.loc = Location.objects.create(name='test')
        self.user = User.objects.create_user(username='test')
        self.booked_duck = Duck.objects.create(species=self.spec,
                                               location=self.loc,
                                               donated_by=self.user)
        self.comp = Competence.objects.create(name='test',
                                              added_by=self.user)

        Booking.objects.create(duck=self.booked_duck,
                               user=self.user,
                               comp_req=self.comp)

    def test_booked_duck(self):
        """
        Test if booked duck returns the booking user from booked_by()
        """

        self.assertNotEqual(self.booked_duck.booked_by(), None)

    def test_unbooked_duck(self):
        """
        Test if unbooked duck returns None from booked_by()
        """

        unbooked_duck = Duck.objects.create(species=self.spec,
                                            location=self.loc,
                                            donated_by=self.user)
        self.assertEqual(unbooked_duck.booked_by(), None)

    def test_multiple_booking(self):
        """
        Test error presence in case of multiple bookings for the same
        duck
        """

        Booking.objects.create(duck=self.booked_duck,
                               user=self.user,
                               comp_req=self.comp)

        with self.assertRaises(RuntimeError):
            self.booked_duck.booked_by()

class StrTest(TestCase):
    """
    Test case for models’ __str__() method
    """

    def setUp(self):
        self.user = User.objects.create_user(username='test')
        self.location = Location.objects.create(name="A Location")
        self.species = Species.objects.create(name="Duck")
        self.competence = Competence.objects.create(name="Testing",
                                                    added_by=self.user)

        self.duck = Duck.objects.create(name="First Duck",
                                        species=self.species,
                                        location=self.location,
                                        donated_by=self.user)

    def test_location_str(self):
        self.assertEquals("A Location", self.location.__str__())

    def test_species_str(self):
        self.assertEquals("Duck", self.species.__str__())

    def test_competence_str(self):
        self.assertEquals("Testing", self.competence.__str__())

    def test_duck_str(self):
        self.assertEquals("First Duck", self.duck.__str__())

    def test_duckname_str(self):
        name_suggestion = DuckName.objects.create(name="New Duck",
                                                  duck=self.duck,
                                                  suggested_by=self.user)
        self.assertEquals("New Duck, suggested by test",
                          name_suggestion.__str__())

        name_suggestion.closed_by = self.user

        self.assertEquals("New Duck, suggested by test <closed>",
                          name_suggestion.__str__())

    def test_ducknamevote_str(self):
        name_suggestion = DuckName.objects.create(name="New Duck",
                                                  duck=self.duck,
                                                  suggested_by=self.user)

        vote = DuckNameVote.objects.create(duck_name=name_suggestion,
                                           voter=self.user,
                                           upvote=False)

        self.assertEquals("test voted down for New Duck, suggested by test",
                          vote.__str__())

        vote.upvote = True

        self.assertEquals("test voted up for New Duck, suggested by test",
                          vote.__str__())

    def test_duckcompetence_str(self):
        dcomp = DuckCompetence.objects.create(duck=self.duck,
                                              comp=self.competence)

        self.assertEquals("First Duck with +0/-0 minutes in Testing",
                          dcomp.__str__())

    def test_booking_str(self):
        start = timezone.now()
        booking = Booking.objects.create(duck=self.duck,
                                         user=self.user,
                                         comp_req=self.competence,
                                         start_ts=start)

        self.assertEquals("First Duck booked by test for Testing since {0}".format(start),
                          booking.__str__())

class SystemCheckTest(TestCase):
    @override_settings()
    def test_max_duck_level_missing(self):
        del settings.MAX_DUCK_LEVEL

        errors = max_level_check(None)

        self.assertGreater(
            len([e for e in errors if e.id == 'booking.E001']),
            0)

    def test_max_duck_level_illegal(self):
        with self.settings(MAX_DUCK_LEVEL=0):
            errors = max_level_check(None)

            self.assertGreater(
                len([e for e in errors if e.id == 'booking.E002']),
                0
            )

        with self.settings(MAX_DUCK_LEVEL=1.1):
            errors = max_level_check(None)

            self.assertGreater(
                len([e for e in errors if e.id == 'booking.E003']),
                0
            )