Squashed commit of the following:

commit 97b044cafb7f17f23b3b1beedcf70af209a60ddc
Author: reverend <reverend@reverend2048.de>
Date:   Mon Sep 14 17:25:40 2020 +0200

    Updating gitignore

commit 4891d80486e1f95db8ae66385c7c97426a3ca1a4
Author: reverend <reverend@reverend2048.de>
Date:   Mon Sep 14 17:25:20 2020 +0200

    Updating Readme

commit f05c43abbdc7eb30896ad6d10fe80fd6483338d9
Author: reverend <reverend@reverend2048.de>
Date:   Mon Sep 14 17:23:30 2020 +0200

    Renaming Module

commit fd5ad2ee9f8cbacd565da45b257928192ffc651c
Author: reverend <reverend@reverend2048.de>
Date:   Mon Sep 14 17:23:16 2020 +0200

    Renaming module references

commit 828a0dd5dd73723b84b77908497903ed26b6966b
Author: reverend <reverend@reverend2048.de>
Date:   Mon Sep 14 17:21:20 2020 +0200

    Renaming Project

django_lostplaces/lostplaces/tests/__init__.py

@@ -0,0 +1,2 @@
+from django.test import TestCase
+from django.contrib.auth.models import User

django_lostplaces/lostplaces/tests/models/__init__.py

@@ -0,0 +1,141 @@
+from django.db import models
+from django.contrib.auth.models import User
+from django.core.exceptions import FieldDoesNotExist
+from django.test import TestCase
+
+# Creating a test user
+
+class ModelTestCase(TestCase):
+    '''
+    Base class for ModelTests.
+    Parameters:
+    - model : Class to test
+    '''
+    model = None
+
+    def assertField(self, field_name, field_class, must_have={}, must_not_have={}):
+        '''
+        Tests if a field exists under the given name and
+        if the field is of the right type.
+        Also checks if the field has the given must_have attributes
+        and does not have any of the must_not_have attributes. If you
+        dont care about the value of the attribute you can just set it to 
+        something that fullfills value == False (i.e. '' or 0)
+        '''
+        try:
+            field = self.model._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            self.fail(
+                'Expecting %s to have a field named \'%s\'' % (
+                    self.model.__name__,
+                    field_name
+                )
+            )
+        self.assertEqual(
+            type(field), field_class,
+            msg='Expecting type of %s to be %s' % (
+                str(field),
+                field_class.__name__
+            )
+        )
+
+        for key, value in must_have.items():
+            if value:
+                self.assertEqual(
+                    getattr(field, key), value,
+                    msg='Expeting the value of %s %s to be \'%s\'' % (
+                        str(field),
+                        key,
+                        value
+                    )
+                )
+            else:
+                self.assertTrue(
+                    hasattr(field, key),
+                    msg='Expeting %s to have \'%s\'' % (
+                        str(field),
+                        key
+                    )
+                )
+
+        for key, value in must_not_have.items():
+            if value:
+                self.assertTrue(
+                    getattr(field, key) != value,
+                    msg='Expeting the value of %s %s to not be \'%s\'' % (
+                        str(field),
+                        key,
+                        value
+                    )
+                )
+            else:
+                self.assertFalse(
+                    hasattr(field, value),
+                    msg='Expeting %s to not have \'%s\'' % (
+                        str(field),
+                        key
+                    )
+                )
+
+        return field
+
+    def assertCharField(self, field_name, min_length, max_length, must_have={}, must_hot_have={}):
+        '''
+        Tests if the given field is a char field and if its max_length
+        is in min_length and max_legth
+        '''
+        field = self.assertField(
+            field_name, models.CharField, must_have, must_hot_have)
+        self.assertTrue(
+            field.max_length in range(min_length, max_length),
+            msg='Expeting %s  max_length to be in the range of %d and %d' % (
+                str(field),
+                min_length,
+                max_length
+            )
+        )
+
+    def assertFloatField(self, field_name, min_value=None, max_value=None, must_have={}, must_hot_have={}):
+        '''
+        Tests if the field is a floatfield. If min_value and/or max_value are passed,
+        the validators of the field are also checked. The validator list of the field should
+        look like 
+        [MinValueValidator, MayValueValidator], if both values are passed,
+        [MinValueValidator] if only min_value is passed,
+        [MaxValueValidator] if only max_value is passed
+        '''
+        field = self.assertField(
+            field_name, models.FloatField, must_have, must_hot_have)
+        if min_value:
+            self.assertTrue(
+                len(field.validators) >= 1,
+                msg='Expecting the first valiator of %s to check the minimum' % (
+                    str(field)
+                )
+            )
+            self.assertEqual(
+                field.validators[0].limit_value,
+                min_value,
+                msg='Expecting the min value of %s min to be at least %d' % (
+                    str(field),
+                    min_value
+                )
+            )
+        if max_value:
+            index = 0
+            if min_value:
+                index += 1
+            self.assertTrue(
+                len(field.validators) >= index+1,
+                msg='Expecting the second valiator of %s to check the maximum' % (
+                    str(field)
+                )
+            )
+            self.assertEqual(
+                field.validators[1].limit_value,
+                max_value,
+                msg='Expecting the max value of %s min to be at most %d' % (
+                    str(field),
+                    max_value
+                )
+            )

django_lostplaces/lostplaces/tests/models/test_abstract_models.py

@@ -0,0 +1,92 @@
+import datetime
+
+from django.test import TestCase
+from django.db import models
+from django.contrib.auth.models import User
+
+from lostplaces.models import (
+    Taggable,
+    Mapable,
+    Submittable
+)
+from lostplaces.tests.models import ModelTestCase
+
+from taggit.managers import TaggableManager
+
+
+class TaggableTestCase(ModelTestCase):
+
+    model = Taggable
+
+    def test_tags(self):
+        self.assertField('tags', TaggableManager)
+
+
+class MapableTestCase(ModelTestCase):
+
+    model = Mapable
+
+    def test_name(self):
+        self.assertCharField(
+            field_name='name',
+            min_length=10,
+            max_length=100
+        )
+
+    def test_latitude(self):
+        self.assertFloatField(
+            field_name='latitude',
+            min_value=-90,
+            max_value=90
+        )
+
+    def test_longitude(self):
+        self.assertFloatField(
+            field_name='longitude',
+            min_value=-180,
+            max_value=180
+        )
+        
+class SubmittableTestCase(ModelTestCase):
+    model = Submittable
+
+    def test_submitted_when(self):
+        self.assertField(
+            field_name='submitted_when',
+            field_class=models.DateTimeField,
+            must_have={'auto_now_add': True}
+        )
+
+    def test_submitted_by(self):
+        submitted_by = self.assertField(
+            field_name='submitted_by',
+            field_class=models.ForeignKey
+        )
+        self.assertEqual(
+            submitted_by.remote_field.related_name,
+            '%(class)s',
+            msg='Expecting the related_name of %s to be \'%%(class)s\', got %s' % (
+                str(submitted_by),
+                submitted_by.remote_field.related_name
+            )
+        )
+        self.assertTrue(
+            submitted_by.null,
+            msg='Expecting %s to has null=True' % (
+                str(submitted_by)
+            )
+        )
+        self.assertTrue(
+            submitted_by.blank,
+            msg='Expecting %s to has blank=True' % (
+                str(submitted_by)
+            )    
+        )
+        self.assertEqual(
+            submitted_by.remote_field.on_delete,
+            models.SET_NULL,
+            msg='Expecting %s to be null when reference is delete (models.SET_NULL)' % (
+                str(submitted_by)
+            )
+        )
+

django_lostplaces/lostplaces/tests/models/test_explorer_model.py

@@ -0,0 +1,58 @@
+from django.test import TestCase
+from django.db import models
+from django.contrib.auth.models import User
+
+from lostplaces.models import Explorer
+
+class ExplorerTestCase(TestCase):
+
+    @classmethod
+    def setUpTestData(self):
+        User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+
+    def test_epxlorer_creation(self):
+        '''
+        Tests if the explorer profile will be automticly
+        created when a user is created
+        '''
+        
+        user = User.objects.get(id=1)
+        explorer_list = Explorer.objects.all()
+        self.assertTrue(len(explorer_list) > 0,
+            msg='Expecting at least one Exlorer object, none found'
+        )
+        self.assertTrue(hasattr(user, 'explorer'),
+            msg='''Expecting the User instance to have an \'explorer\' attribute. 
+            Check the Explorer model and the related name.'''
+        )
+        
+        explorer = Explorer.objects.get(id=1)
+        self.assertEqual(explorer, user.explorer,
+            msg='''The Explorer object of the User did not match.
+            Expecting User with id 1 to have Explorer with id 1'''
+        )
+        
+        explorer = Explorer.objects.get(id=1)
+        self.assertEqual(explorer.user, user,
+            msg='''The User object of the Explorer did not match.
+            Expecting Explorer with id 1 to have User with id 1'''
+        )
+        
+    def test_explorer_deletion(self):
+        '''
+        Tests if the Explorer objects get's deleted when the User instance is deleted
+        '''
+        
+        user = User.objects.get(username='testpeter')
+        explorer_id = user.explorer.id
+        user.delete()
+        with self.assertRaises(models.ObjectDoesNotExist,
+            msg='Expecting explorer objec to be deleted when the corresponding User object is deleted'
+            ):
+            Explorer.objects.get(id=explorer_id)
+        
+        
+    

django_lostplaces/lostplaces/tests/models/test_place_image_model.py

@@ -0,0 +1,108 @@
+import datetime
+import os
+import shutil
+from unittest import mock
+
+from django.test import TestCase
+from django.db import models
+from django.core.files import File
+from django.conf import settings
+from django.contrib.auth.models import User
+
+from lostplaces.models import PlaceImage, Place
+from lostplaces.tests.models import ModelTestCase
+
+from easy_thumbnails.fields import ThumbnailerImageField
+
+class PlaceImageTestCase(ModelTestCase):
+    model = PlaceImage
+
+    @classmethod
+    def setUpTestData(cls):
+        user = User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+        
+        place = Place.objects.create(
+            name='Im a place',
+            submitted_when=datetime.datetime.now(),
+            submitted_by=User.objects.get(username='testpeter').explorer,
+            location='Testtown',
+            latitude=50.5,
+            longitude=7.0,
+            description='This is just a test, do not worry'
+        )
+        place.tags.add('I a tag', 'testlocation')
+        place.save()
+
+        if not os.path.isdir(settings.MEDIA_ROOT):
+            os.mkdir(settings.MEDIA_ROOT)
+
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        if not os.path.isfile(os.path.join(settings.MEDIA_ROOT, 'im_a_image_copy.jpeg')):
+            shutil.copyfile(
+                os.path.join(current_dir, 'im_a_image.jpeg'),
+                os.path.join(settings.MEDIA_ROOT, 'im_a_image_copy.jpeg')
+            )
+            
+            shutil.copyfile(
+                os.path.join(current_dir, 'im_a_image.jpeg'),
+                os.path.join(settings.MEDIA_ROOT, 'im_a_image_changed.jpeg')
+            )
+            
+        PlaceImage.objects.create(
+            description='Im a description',
+            filename=os.path.join(settings.MEDIA_ROOT, 'im_a_image_copy.jpeg'),
+            place=place,
+            submitted_when=datetime.datetime.now(),
+            submitted_by=user.explorer
+        )
+
+    def setUp(self):
+        self.place_image = PlaceImage.objects.get(id=1)
+
+    def test_description(self):
+        self.assertField('description', models.TextField)
+
+    def test_filename(self):
+        self.assertField('filename',ThumbnailerImageField)
+
+    def test_place(self):
+        field = self.assertField('place', models.ForeignKey)
+        self.assertEqual(field.remote_field.on_delete, models.CASCADE,
+            msg='Expecting the deletion of %s to be cascading' % (
+                str(field)
+            )
+        )
+        expected_related_name = 'placeimages'
+        self.assertEqual(field.remote_field.related_name, expected_related_name,
+            msg='Expecting the related name of %s to be %s' % (
+                str(field),
+                expected_related_name
+            )
+        )
+
+    def test_str(self):
+        self.assertTrue(self.place_image.place.name.lower() in str(self.place_image).lower(),
+            msg='Expecting %s.__str__ to contain  the name of the place' % (
+                self.model.__name__
+            )
+        )
+        
+    def test_change_filename(self):
+        path = self.place_image.filename.path
+        self.place_image.filename = os.path.join(settings.MEDIA_ROOT, 'im_a_image_changed.jpeg')
+        self.place_image.save()
+        self.assertFalse(
+            os.path.isfile(path),
+            msg='Expecting the old file of an place_image to be deleteed when an place_image file is changed'
+        )
+        
+    def test_deletion(self):
+        path = self.place_image.filename.path
+        self.place_image.delete()
+        self.assertFalse(
+            os.path.isfile(path),
+            msg='Expecting the file of an place_image to be deleteed when an place_image is deleted'
+        )

django_lostplaces/lostplaces/tests/models/test_place_model.py

@@ -0,0 +1,124 @@
+import datetime
+
+from django.test import TestCase
+from django.db import models
+
+from django.contrib.auth.models import User
+
+from lostplaces.models import Place
+from lostplaces.tests.models import ModelTestCase
+
+class PlaceTestCase(ModelTestCase):
+    model = Place
+    related_name = 'places'
+    nullable = True
+
+    @classmethod
+    def setUpTestData(cls):
+        user = User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+        
+        place = Place.objects.create(
+            name='Im a place',
+            submitted_when=datetime.datetime.now(),
+            submitted_by=user.explorer,
+            location='Testtown',
+            latitude=50.5,
+            longitude=7.0,
+            description='This is just a test, do not worry'
+        )
+        place.tags.add('I a tag', 'testlocation')
+        place.save()
+
+
+    def setUp(self):
+        self.place = Place.objects.get(id=1)
+
+    def test_location(self):
+        self.assertCharField(
+            field_name='location',
+            min_length=10,
+            max_length=100
+        )
+
+    def test_decsription(self):
+        self.assertField('description', models.TextField)
+
+    def test_average_latlon(self):
+        '''
+        Tests the average latitude/longitude calculation of a list
+        of 10 places
+        '''
+        place_list = []
+        for i in range(10):
+            place = Place.objects.get(id=1)
+            place.id = None
+            place.latitude = i+1
+            place.longitude = i+10
+            place.save()
+            place_list.append(place)
+
+        avg_latlon = Place.average_latlon(place_list)
+        
+        self.assertTrue('latitude' in avg_latlon,
+            msg='Expecting avg_latlon dict to have an \'latitude\' key'
+        )
+        self.assertTrue('longitude' in avg_latlon,
+            msg='Expecting avg_latlon dict to have an \'longitude\' key'
+        )
+        
+        self.assertEqual(avg_latlon['latitude'], 5.5,
+            msg='%s: average latitude missmatch' % (
+                self.model.__name__
+            )
+        )
+        self.assertEqual(avg_latlon['longitude'], 14.5,
+            msg='%s: average longitude missmatch' % (
+                self.model.__name__
+            )
+        )
+
+    def test_average_latlon_one_place(self):
+        '''
+        Tests the average latitude/longitude calculation of a list
+        of one place
+        '''
+        place = Place.objects.get(id=1)
+        avg_latlon = Place.average_latlon([place])
+        self.assertEqual(avg_latlon['latitude'], place.latitude,
+            msg='%s:(one place) average latitude missmatch' % (
+                self.model.__name__
+            )
+        )
+        self.assertEqual(avg_latlon['longitude'], place.longitude,
+            msg='%s: (one place) average longitude missmatch' % (
+                self.model.__name__
+            )
+        )
+
+    def test_average_latlon_no_places(self):
+        '''
+        Tests the average latitude/longitude calculation of 
+        an empty list
+        '''
+        avg_latlon = Place.average_latlon([])
+        self.assertEqual(avg_latlon['latitude'], 0,
+            msg='%s: (no places) average latitude missmatch' % (
+                self.model.__name__
+            )
+        )
+        self.assertEqual(avg_latlon['longitude'], 0,
+            msg='%s: a(no places) verage longitude missmatch' % (
+                self.model.__name__
+            )
+        )
+
+    def test_str(self):
+        place = self.place
+        self.assertTrue(place.name.lower() in str(place).lower(),
+            msg='Expecting %s.__str__ to contain the name' % (
+                self.model.__name__
+            )
+        )

django_lostplaces/lostplaces/tests/models/test_voucher_model.py

@@ -0,0 +1,52 @@
+import datetime
+
+from django.test import TestCase
+from django.db import models
+from django.utils import timezone
+
+from lostplaces.models import Voucher
+from lostplaces.tests.models import ModelTestCase
+
+
+class VoucheTestCase(ModelTestCase):
+    model = Voucher
+
+    @classmethod
+    def setUpTestData(cls):
+        Voucher.objects.create(
+            code='ayDraJCCwfhcFiYmSR5GrcjcchDfcahv',
+            expires_when=timezone.now() + datetime.timedelta(days=1)
+        )
+        
+    def setUp(self):
+        self.voucher = Voucher.objects.get(id=1)
+    
+    def test_voucher_code(self):
+        self.assertCharField(
+            field_name='code',
+            min_length=10,
+            max_length=100,
+            must_have={'unique': True}
+        )
+        
+    def test_voucher_created(self):
+        self.assertField(
+            field_name='created_when',
+            field_class=models.DateTimeField,
+            must_have={'auto_now_add': True}
+        )
+        
+    def test_voucher_expires(self):
+        self.assertField(
+            field_name='expires_when',
+            field_class=models.DateTimeField,
+            must_not_have={'auto_now_add': True}
+        )
+
+    def test_str(self):
+        self.assertTrue(
+            self.voucher.code.lower() in str(self.voucher).lower(),
+            msg='Expecting %s.__str__ to contain the voucher code' % (
+                self.model.__name__
+            )
+        )

django_lostplaces/lostplaces/tests/views/__init__.py

@@ -0,0 +1,224 @@
+from django.test import TestCase
+
+from lostplaces.models import Taggable, Mapable
+
+from taggit.models import Tag
+
+class ViewTestCase(TestCase):
+    '''
+    This is a mixni for testing views. It provides functionality to
+    test the context, forms and HTTP Response of responses. 
+    All methods take responses, so this base class can be used
+    with django's RequestFactory and Test-Client
+    '''
+    view = None
+    
+    def assertContext(self, response, key, value=None):
+        '''
+        Checks weather the response's context has the given key
+        and, if passed, checks the value
+        '''
+        self.assertTrue(
+            key in response.context,
+            msg='Expecting the context of %s to have an attribute \'%s\'' % (
+                self.view.__name__,
+                key
+            )
+        )
+
+        if value:
+            self.assertEqual(
+                value,
+                response.context[key],
+                msg='Expecting the context of %s to have %s set to \'%s\'' % (
+                    self.view.__name__,
+                    key, 
+                    str(value)
+                )
+            )
+        
+    def assertHasForm(self, response, key, form_class):
+        '''
+        Checks if response has a form under the given key and if 
+        the forms class matches.
+        '''
+        self.assertContext(response, key)
+        self.assertEqual(
+            type(response.context[key]),
+            form_class,
+            msg='Expecting %s\'s context.%s to be of the type %s' % (
+                self.view.__name__,
+                key,
+                form_class.__name__
+            ) 
+        )
+
+    def assertHttpCode(self, response, code):
+        '''
+        Checks if the response has the given status code
+        '''
+        self.assertEqual(
+            response.status_code, code,
+            msg='Expecting an HTTP %s response, but got HTTP %s' % (
+                code,
+                response.status_code
+            )
+        )
+        
+    def assertHttpRedirect(self, response, redirect_to=None):
+        '''
+        Checks weather the response redirected, and if passed, 
+        if it redirected to the expected loaction
+        '''
+        
+        self.assertTrue(
+            300 <= response.status_code < 400,
+            'Expected an HTTP 3XX (redirect) response, but got HTTP %s' %
+            response.status_code
+        )
+        self.assertTrue(
+            'location' in response,
+            msg='Expecting a redirect to have an location, got none'
+        )
+        if redirect_to:
+            self.assertEqual(
+                response['location'],
+                redirect_to,
+                msg='Expecing the response to redirect to %s, where redirected to %s instea' % (
+                    str(redirect_to),
+                    str(response['location'])
+                )
+            )
+
+    def assertHttpOK(self, response):
+        self.assertHttpCode(response, 200)
+
+    def assertHttpCreated(self, response):
+        self.assertHttpCode(response, 201)
+
+    def assertHttpBadRequest(self, response):
+        self.assertHttpCode(response, 400)
+
+    def assertHttpUnauthorized(self, response):
+        self.assertHttpCode(response, 401)
+
+    def assertHttpForbidden(self, response):
+        self.assertHttpCode(response, 403)
+
+    def assertHttpNotFound(self, response):
+        self.assertHttpCode(response, 404)
+
+    def assertHttpMethodNotAllowed(self, response):
+        self.assertHttpCode(response, 405)
+        
+class TaggableViewTestCaseMixin:
+
+    def assertTaggableContext(self, context):
+        self.assertTrue(
+            'all_tags' in context,
+            msg='Expecting the context for taggable to contain an \'all_tags\' attribute'
+        )
+        
+        for tag in context['all_tags']:
+            self.assertTrue(
+                isinstance(tag, Tag),
+                msg='Expecting all entries to be an instance of %s, got %s' % (
+                    str(Tag),
+                    str(type(tag))
+                )
+            )
+            
+        self.assertTrue(
+            'submit_form' in context,
+            msg='Expecting the context for taggable to contain \'submit_form\' attribute'
+        )
+        
+        self.assertTrue(
+            'tagged_item' in context,
+            msg='Expecting the context for taggable to contain \'tagged_item\' attribute'
+        )
+        
+        self.assertTrue(
+            isinstance(context['tagged_item'], Taggable),
+            msg='Expecting the tagged_item to be an instance of %s' % (
+                str(Taggable)
+            )
+        )
+        
+        self.assertTrue(
+            'submit_url_name' in context,
+            msg='Expecting the context for taggable to contain \'submit_url_name\' attribute'
+        )
+        
+        self.assertTrue(
+            type(context['submit_url_name']) == str,
+            msg='Expecting submit_url_name to be of type string'
+        )
+        
+        self.assertTrue(
+            'delete_url_name' in context,
+            msg='Expecting the context for taggable to contain \'delete_url_name\' attribute'
+        )
+        
+        self.assertTrue(
+            type(context['delete_url_name']) == str,
+            msg='Expecting delete_url_name to be of type string'
+        )
+        
+class MapableViewTestCaseMixin:
+    
+    def assertMapableContext(self, context):
+        self.assertTrue(
+            'all_points' in context,
+            msg='Expecting the context for mapable point to contain \'all_points\' attribute'
+        )
+        
+        for point in context['all_points']:
+            self.assertTrue(
+                isinstance(point, Mapable),
+                msg='Expecting all entries to be an instance of %s, got %s' % (
+                    str(Mapable),
+                    str(type(point))
+                )
+            )
+            
+        self.assertTrue(
+            'map_center' in context,
+            msg='Expecting the context for mapable point to contain \'map_center\' attribute'
+        )
+        
+        self.assertTrue(
+            'latitude' in context['map_center'],
+            msg='Expecting the map center to contain an \'latitude\' attribute'
+        )
+        
+        self.assertTrue(
+            isinstance(context['map_center']['latitude'], float) or isinstance(context['map_center']['latitude'], int),
+            msg='Expecting the latitude of the map center to be numeric, type %s given' % (
+                str(type(context['map_center']['latitude']))
+            )
+        )
+        
+        self.assertTrue(
+            -90 <= context['map_center']['latitude'] <= 90,
+            msg='Expecting the latitude of map center to be in the range of -90 and 90'
+        )
+        
+        self.assertTrue(
+            'longitude' in context['map_center'],
+            msg='Expecting the map center to contain an \'longitude\' attribute'
+        )
+        
+        self.assertTrue(
+            isinstance(context['map_center']['longitude'], float) or isinstance(context['map_center']['longitude'], int),
+            msg='Expecting the longitude of the map center to be numeric, type %s given' % (
+                str(type(context['map_center']['longitude']))
+            )
+        )
+        
+        self.assertTrue(
+            -180 <= context['map_center']['longitude'] <= 180,
+            msg='Expecting the longitude of map center to be in the range of -180 and 180'
+        )
+            
+        

django_lostplaces/lostplaces/tests/views/test_base_views.py

@@ -0,0 +1,87 @@
+import datetime
+
+from django.test import TestCase, RequestFactory, Client
+from django.urls import reverse_lazy
+from django.contrib.auth.models import User, AnonymousUser
+from django.contrib.messages.storage.fallback import FallbackStorage
+
+from lostplaces.models import Place
+from lostplaces.views import IsAuthenticatedMixin
+from lostplaces.tests.views import ViewTestCase
+
+class TestIsAuthenticated(ViewTestCase):
+    view = IsAuthenticatedMixin
+
+    @classmethod
+    def setUpTestData(cls):
+        user = User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+        
+    def setUp(self):
+        self.client = Client()
+
+    def test_logged_in(self):
+        request = RequestFactory().get('/')
+        request.user = User.objects.get(id=1)
+
+        response = IsAuthenticatedMixin.as_view()(request)
+        # Expecting a 405 because IsAuthenticatedMixin has no 'get' method
+        self.assertHttpMethodNotAllowed(response)
+
+    def test_not_logged_in(self):
+        request = RequestFactory().get('/someurl1234')
+        request.user = AnonymousUser()
+        request.session = 'session'
+        messages = FallbackStorage(request)
+        request._messages = messages
+
+        response = IsAuthenticatedMixin.as_view()(request)
+        self.assertHttpRedirect(response, '?'.join([str(reverse_lazy('login')), 'next=/someurl1234']))
+        
+        response = self.client.get(response['Location']) 
+        self.assertTrue(len(messages) > 0)
+
+class TestIsPlaceSubmitterMixin(TestCase):
+
+    @classmethod
+    def setUpTestData(cls):
+        user = User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+        
+        place = Place.objects.create(
+            name='Im a place',
+            submitted_when=datetime.datetime.now(),
+            submitted_by=user.explorer,
+            location='Testtown',
+            latitude=50.5,
+            longitude=7.0,
+            description='This is just a test, do not worry'
+        )
+        place.tags.add('I a tag', 'testlocation')
+        place.save()
+        
+    def setUp(self):
+        self.client = Client()
+
+    def setUp(self):
+        self. client = Client()
+
+    def test_is_submitter(self):
+        self.client.login(username='testpeter', password='Develop123')
+        response = self.client.get(reverse_lazy('place_edit', kwargs={'pk': 1}))
+        self.assertEqual(response.status_code, 200)
+
+    def test_is_no_submitter(self):
+        User.objects.create_user(
+            username='manfred',
+            password='Develop123'
+        )
+        self.client.login(username='manfred', password='Develop123')
+        response = self.client.get(reverse_lazy('place_edit', kwargs={'pk': 1}))
+        self.assertEqual(response.status_code, 403)
+        self.assertTrue(response.context['messages'])
+        self.assertTrue(len(response.context['messages']) > 0)

django_lostplaces/lostplaces/tests/views/test_place_views.py

@@ -0,0 +1,126 @@
+import datetime
+
+from django.test import TestCase, Client
+from django.urls import reverse
+from django.contrib.auth.models import User
+
+from lostplaces.models import Place
+from lostplaces.views import (
+    PlaceCreateView,
+    PlaceListView,
+    PlaceDetailView
+)
+from lostplaces.forms import PlaceImageCreateForm, PlaceForm
+from lostplaces.tests.views import (
+    ViewTestCase,
+    TaggableViewTestCaseMixin,
+    MapableViewTestCaseMixin
+)
+
+
+class TestPlaceCreateView(ViewTestCase):
+    view = PlaceCreateView
+
+    @classmethod
+    def setUpTestData(cls):
+        user = User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+
+        place = Place.objects.create(
+            name='Im a place',
+            submitted_when=datetime.datetime.now(),
+            submitted_by=user.explorer,
+            location='Testtown',
+            latitude=50.5,
+            longitude=7.0,
+            description='This is just a test, do not worry'
+        )
+        place.tags.add('I a tag', 'testlocation')
+        place.save()
+
+    def setUp(self):
+        self.client = Client()
+
+    def test_has_forms(self):
+        self.client.login(username='testpeter', password='Develop123')
+        response = self.client.get(reverse('place_create'))
+
+        self.assertHasForm(response, 'place_image_form', PlaceImageCreateForm)
+        self.assertHasForm(response, 'place_form', PlaceForm)
+
+
+class TestPlaceListView(ViewTestCase):
+    view = PlaceListView
+
+    @classmethod
+    def setUpTestData(cls):
+        user = User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+
+        place = Place.objects.create(
+            name='Im a place',
+            submitted_when=datetime.datetime.now(),
+            submitted_by=user.explorer,
+            location='Testtown',
+            latitude=50.5,
+            longitude=7.0,
+            description='This is just a test, do not worry'
+        )
+        place.tags.add('I a tag', 'testlocation')
+        place.save()
+
+    def setUp(self):
+        self.client = Client()
+
+    def test_list_view(self):
+        self.client.login(username='testpeter', password='Develop123')
+        response = self.client.get(reverse('place_list'))
+
+        self.assertContext(response, 'mapping_config')
+
+
+class PlaceDetailViewTestCase(TaggableViewTestCaseMixin, MapableViewTestCaseMixin, ViewTestCase):
+    view = PlaceDetailView
+
+    @classmethod
+    def setUpTestData(cls):
+        user = User.objects.create_user(
+            username='testpeter',
+            password='Develop123'
+        )
+
+        place = Place.objects.create(
+            name='Im a place',
+            submitted_when=datetime.datetime.now(),
+            submitted_by=user.explorer,
+            location='Testtown',
+            latitude=50.5,
+            longitude=7.0,
+            description='This is just a test, do not worry'
+        )
+        place.tags.add('I a tag', 'testlocation')
+        place.save()
+
+    def test_context(self):
+        self.client.login(username='testpeter', password='Develop123')
+        response = self.client.get(reverse('place_detail', kwargs={'pk': 1}))
+
+        self.assertTrue(
+            'tagging_config' in response.context,
+            msg='Expecting the context of %s to have an \'tagging_config\'' % (
+                str(self.view)
+            )
+        )
+        self.assertTaggableContext(response.context['tagging_config'])
+
+        self.assertTrue(
+            'mapping_config' in response.context,
+            msg='Expecting the context of %s to have an \'mapping_config\'' % (
+                str(self.view)
+            )
+        )
+        self.assertMapableContext(response.context['mapping_config'])