Commander1024/lostplaces-backend
1
0
Fork 0
Code Issues 14 Pull Requests Releases Wiki Activity

Squashed commit of the following:

Browse Source 
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
This commit is contained in:
reverend
2020-09-14 17:26:17 +02:00
parent 0765f6606f
commit 547179b0ca
97 changed files with 53 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
django_lostplaces/lostplaces/tests/models/__init__.py Normal file
View File

@@ -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
)
)

BIN
django_lostplaces/lostplaces/tests/models/im_a_image.jpeg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 81 KiB

92
django_lostplaces/lostplaces/tests/models/test_abstract_models.py Normal file
View File

@@ -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)
)
)

58
django_lostplaces/lostplaces/tests/models/test_explorer_model.py Normal file
View File

@@ -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)

108
django_lostplaces/lostplaces/tests/models/test_place_image_model.py Normal file
View File

@@ -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'
)

124
django_lostplaces/lostplaces/tests/models/test_place_model.py Normal file
View File

@@ -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__
)
)

52
django_lostplaces/lostplaces/tests/models/test_voucher_model.py Normal file
View File

@@ -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__
)
)