import random import datetime from django.urls import reverse from django.test import TestCase from django.utils import timezone from rest_framework.test import APITestCase from rest_framework import status import jwt from tenants.factories import TenantUserFactory from . import models from . import factories # Model Tests class CountryTest(TestCase): """Country model tests """ def setUp(self): """Tests setup """ self.model = models.Country def test_content(self): """Test content correctly set """ # Define instance data data = { 'name': 'country name _test_ data' } # Create instance instance = self.model.objects.create(**data) # Assert content correctly set for field in data.keys(): self.assertEqual(getattr(instance, field), data[field]) class RegionTest(TestCase): """Region model tests """ def setUp(self): """Tests setup """ self.model = models.Region def test_content(self): """Test content correctly set """ # Define instance data data = { 'name': 'region name _test_ data', 'country': factories.CountryFactory(), } # Create instance instance = self.model.objects.create(**data) # Assert content correctly set for field in data.keys(): self.assertEqual(getattr(instance, field), data[field]) class CityTest(TestCase): """City model tests """ def setUp(self): """Tests setup """ self.model = models.City def test_content(self): """Test content correctly set """ # Define instance data data = { 'name': 'city name _test_ data', 'region': factories.RegionFactory(), } # Create instance instance = self.model.objects.create(**data) # Assert content correctly set for field in data.keys(): self.assertEqual(getattr(instance, field), data[field]) class JurisdictionTest(TestCase): """Jurisdiction model tests """ def setUp(self): """Tests setup """ self.model = models.Jurisdiction def test_content(self): """Test content correctly set """ # Define instance data data = { 'name': 'jurisdiction name test data', 'region': factories.RegionFactory(), } # Create instance instance = self.model.objects.create(**data) # Assert content correctly set for field in data.keys(): self.assertEqual(getattr(instance, field), data[field]) # ViewSet Tests class CountryViewSetTest(APITestCase): """Country viewset tests """ databases = {'default', 'tenants'} def setUp(self): """Tests setup """ self.endpoint = '/api/v1/countries/' self.factory = factories.CountryFactory self.model = models.Country def test_not_logged_user_cannot_create_country(self): """Not logged-in user cannot create new country """ # Query endpoint response = self.client.post(self.endpoint, data={}) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_modify_existing_country(self): """Not logged-in user cannot modify existing country """ # Create instance instance = self.factory() # Query endpoint url = self.endpoint + f'{instance.pk}/' response = self.client.put(url, {}, format='json') # Assert forbidden code self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_delete_existing_country(self): """Not logged-in user cannot delete existing country """ # Create instances instance = self.factory() # Query endpoint url = self.endpoint + f'{instance.pk}/' response = self.client.delete(url) # Assert instance still exists on db self.assertTrue(self.model.objects.get(id=instance.pk)) def test_not_logged_user_cannot_list_country(self): """Not logged-in user can't read country """ # Request list # url = reverse(self.endpoint+'list') response = self.client.get(self.endpoint) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_logged_user_can_list_country(self): """Regular logged-in user can list country """ # Create instances user = TenantUserFactory() instances = [self.factory() for n in range(random.randint(1,5))] # Authenticate user user.db = 'default' self.client.force_authenticate(user=user) # Request list response = self.client.get(self.endpoint) # Assert access is allowed self.assertEqual(response.status_code, status.HTTP_200_OK) # Assert all instances are returned self.assertEqual(len(instances), len(response.data['results'])) def test_logged_user_can_create_country(self): """Regular logged-in user can create new country """ # Define request data data = { 'name': 'country name _test_ data', } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint response = self.client.post(self.endpoint, data=data) # Assert endpoint returns created status self.assertEqual(response.status_code, status.HTTP_201_CREATED) # Assert instance exists on db self.assertTrue(self.model.objects.get(id=response.data['id'])) def test_logged_user_can_modify_existing_country(self): """Regular logged-in user can modify existing country """ # Create instances instance = self.factory() # Define request data data = { 'name': 'country name _test_ data', } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = self.endpoint + f'{instance.pk}/' response = self.client.put(url, data=data, format='json') # Assert endpoint returns OK code self.assertEqual(response.status_code, status.HTTP_200_OK) # Assert instance has been modified for key in data: self.assertEqual(data[key], response.data[key]) def test_logged_user_can_delete_existing_country(self): """Regular logged-in user can delete existing country """ # Create instances instance = self.factory() # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = self.endpoint + f'{instance.pk}/' response = self.client.delete(url) # assert 204 no content self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) # Assert instance doesn't exists anymore on db self.assertFalse(self.model.objects.filter(id=instance.pk).exists()) class RegionViewSetTest(APITestCase): """Region viewset tests """ databases = {'default', 'tenants'} def setUp(self): """Tests setup """ self.endpoint = 'api-v1:region-' self.factory = factories.RegionFactory self.model = models.Region def test_not_logged_user_cannot_create_region(self): """Not logged-in user cannot create new region """ # Query endpoint url = reverse(self.endpoint+'list') response = self.client.post(url, data={}) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_modify_existing_region(self): """Not logged-in user cannot modify existing region """ # Create instance instance = self.factory() # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.put(url, {}, format='json') # Assert forbidden code self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_delete_existing_region(self): """Not logged-in user cannot delete existing region """ # Create instances instance = self.factory() # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.delete(url) # Assert instance still exists on db self.assertTrue(self.model.objects.get(id=instance.pk)) def test_not_logged_user_cant_list_region(self): """Not logged-in user can't read region """ # Request list url = reverse(self.endpoint+'list') response = self.client.get(url) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_logged_user_can_list_region(self): """Regular logged-in user can list region """ # Create instances user = TenantUserFactory() instances = [self.factory() for n in range(random.randint(1,5))] # Authenticate user user.db = 'default' self.client.force_authenticate(user=user) # Request list url = reverse(self.endpoint+'list') response = self.client.get(url) # Assert access is allowed self.assertEqual(response.status_code, status.HTTP_200_OK) # Assert all instances are returned self.assertEqual(len(instances), len(response.data['results'])) def test_logged_user_can_create_region(self): """Regular logged-in user can create new region """ # Define request data data = { 'name': 'country name _test_ data', 'country': factories.CountryFactory().pk, } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'list') response = self.client.post(url, data=data) # Assert endpoint returns created status self.assertEqual(response.status_code, status.HTTP_201_CREATED) # Assert instance exists on db self.assertTrue(self.model.objects.get(id=response.data['id'])) def test_logged_user_can_modify_existing_region(self): """Regular logged-in user can modify existing region """ # Create instances instance = self.factory() # Define request data data = { 'name': 'country name _test_ data', 'country': factories.CountryFactory().pk, } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.put(url, data, format='json') # Assert endpoint returns OK code self.assertEqual(response.status_code, status.HTTP_200_OK) def test_logged_user_can_delete_existing_region(self): """Regular logged-in user can delete existing region """ # Create instances instance = self.factory() # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.delete(url) # assert 204 no content self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) # Assert instance not exists anymore on db self.assertFalse(self.model.objects.filter(id=instance.pk).exists()) class CityViewSetTest(APITestCase): """City viewset tests """ databases = {'default', 'tenants'} def setUp(self): """Tests setup """ self.endpoint = 'api-v1:city-' self.factory = factories.CityFactory self.model = models.City def test_not_logged_user_cannot_create_city(self): """Not logged-in user cannot create new city """ # Query endpoint url = reverse(self.endpoint+'list') response = self.client.post(url, data={}) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_modify_existing_city(self): """Not logged-in user cannot modify existing city """ # Create instance instance = self.factory() # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.put(url, {}, format='json') # Assert forbidden code self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_delete_existing_city(self): """Not logged-in user cannot delete existing city """ # Create instances instance = self.factory() # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.delete(url) # Assert instance still exists on db self.assertTrue(self.model.objects.get(id=instance.pk)) def test_not_logged_user_cant_list_city(self): """Not logged-in user can't read city """ # Request list url = reverse(self.endpoint+'list') response = self.client.get(url) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_logged_user_can_list_city(self): """Regular logged-in user can list city """ # Create instances user = TenantUserFactory() instances = [self.factory() for n in range(random.randint(1,5))] # Authenticate user user.db = 'default' self.client.force_authenticate(user=user) # Request list url = reverse(self.endpoint+'list') response = self.client.get(url) # Assert access is allowed self.assertEqual(response.status_code, status.HTTP_200_OK) # Assert all instances are returned self.assertEqual(len(instances), len(response.data['results'])) def test_logged_user_can_create_city(self): """Regular logged-in user can create new city """ # Define request data data = { 'name': 'country name _test_ data', 'region': factories.RegionFactory().pk, } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'list') response = self.client.post(url, data=data) # Assert endpoint returns created status self.assertEqual(response.status_code, status.HTTP_201_CREATED) # Assert instance exists on db self.assertTrue(self.model.objects.get(id=response.data['id'])) def test_logged_user_can_modify_existing_city(self): """Regular logged-in user can modify existing citycity """ # Create instances instance = self.factory() # Define request data data = { 'name': 'country name _test_ data', 'region': factories.RegionFactory().pk, } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.put(url, data, format='json') # Assert endpoint returns OK code self.assertEqual(response.status_code, status.HTTP_200_OK) def test_logged_user_can_delete_existing_city(self): """Regular logged-in user can delete existing city """ # Create instances instance = self.factory() # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.delete(url) # Assert 204 no content self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) # Assert instance doesn't exists on db anymore self.assertFalse(self.model.objects.filter(id=instance.pk).exists()) class JurisdictionViewSetTest(APITestCase): """Jurisdiction viewset tests """ databases = {'default', 'tenants'} def setUp(self): """Tests setup """ self.endpoint = 'api-v1:jurisdiction-' self.factory = factories.JurisdictionFactory self.model = models.Jurisdiction def test_not_logged_user_cannot_create_jurisdiction(self): """Not logged-in user cannot create new city """ # Query endpoint url = reverse(self.endpoint+'list') response = self.client.post(url, data={}) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_modify_existing_jurisdiction(self): """Not logged-in user cannot modify existing city """ # Create instance instance = self.factory() # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.put(url, {}, format='json') # Assert forbidden code self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_not_logged_user_cannot_delete_existing_jurisdiction(self): """Not logged-in user cannot delete existing city """ # Create instances instance = self.factory() # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.delete(url) # Assert instance still exists on db self.assertTrue(self.model.objects.get(id=instance.pk)) def test_not_logged_user_cant_list_jurisdiction(self): """Not logged-in user can't read city """ # Request list url = reverse(self.endpoint+'list') response = self.client.get(url) # Assert access is forbidden self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_logged_user_can_list_jurisdiction(self): """Regular logged-in user can list city """ # Create instances user = TenantUserFactory() instances = [self.factory() for n in range(random.randint(1,5))] # Authenticate user user.db = 'default' self.client.force_authenticate(user=user) # Request list url = reverse(self.endpoint+'list') response = self.client.get(url) # Assert access is allowed self.assertEqual(response.status_code, status.HTTP_200_OK) # Assert all instances are returned self.assertEqual(len(instances), len(response.data['results'])) def test_logged_user_can_create_jurisdiction(self): """Regular logged-in user can create new city """ # Define request data data = { 'name': 'jurisdiction name test data', 'region': factories.RegionFactory().pk, } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'list') response = self.client.post(url, data=data) # Assert endpoint returns created status self.assertEqual(response.status_code, status.HTTP_201_CREATED) # Assert instance exists on db self.assertTrue(self.model.objects.get(id=response.data['id'])) def test_logged_user_can_modify_existing_jurisdiction(self): """Regular logged-in user can modify existing citycity """ # Create instances instance = self.factory() # Define request data data = { 'name': 'jurisdiction name test MOD data', 'region': factories.RegionFactory().pk, } # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.put(url, data, format='json') # Assert endpoint returns OK code self.assertEqual(response.status_code, status.HTTP_200_OK) # Assert instance has been modified for key in data: self.assertEqual(data[key], response.data[key]) def test_logged_user_can_delete_existing_jurisdiction(self): """Regular logged-in user can delete existing city """ # Create instances instance = self.factory() # Authenticate user user = TenantUserFactory() user.db = 'default' self.client.force_authenticate(user=user) # Query endpoint url = reverse(self.endpoint+'detail', args=[instance.pk]) response = self.client.delete(url) # Assert 204 no content self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) # Assert instance not exists anymore on db self.assertFalse(self.model.objects.filter(id=instance.pk).exists())