From a7f1b8a577937fc676da5754fe1e3c9d938aae9b Mon Sep 17 00:00:00 2001
From: gamsus <92788796+gamsus@users.noreply.github.com>
Date: Tue, 23 Jan 2024 22:54:15 +0100
Subject: [PATCH 1/2] Update tests.py
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

pare prostych testów do users
---
 backend/users/tests.py | 129 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 128 insertions(+), 1 deletion(-)

diff --git a/backend/users/tests.py b/backend/users/tests.py
index 7ce503c..9c6b7ee 100644
--- a/backend/users/tests.py
+++ b/backend/users/tests.py
@@ -1,3 +1,130 @@
 from django.test import TestCase
 
-# Create your tests here.
+# test.py
+
+# tests.py
+
+from django.contrib.auth import get_user_model
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.contrib.auth import get_user_model
+from django.urls import reverse
+from django.contrib.auth import get_user_model
+from django.core import mail
+
+from backend.users.serializers import UserSerializer
+
+class UserModelTest(TestCase):
+    def setUp(self):
+        """
+        Set up test data for User model tests.
+        """
+        # Create a regular user
+        self.user_data = {
+            'email': 'test@example.com',
+            'name': 'John',
+            'surname': 'Doe',
+            'password': 'password123'
+        }
+        self.user = get_user_model().objects.create_user(**self.user_data)
+
+        # Create a superuser
+        self.superuser_data = {
+            'email': 'admin@example.com',
+            'name': 'Admin',
+            'surname': 'User',
+            'password': 'adminpassword'
+        }
+        self.superuser = get_user_model().objects.create_superuser(**self.superuser_data)
+
+    def test_create_user(self):
+        """
+        Test creating a regular user.
+        """
+        self.assertEqual(self.user.email, self.user_data['email'])
+        self.assertTrue(self.user.check_password(self.user_data['password']))
+        self.assertFalse(self.user.is_superuser)
+        self.assertFalse(self.user.is_staff)
+
+    def test_create_superuser(self):
+        """
+        Test creating a superuser.
+        """
+        self.assertEqual(self.superuser.email, self.superuser_data['email'])
+        self.assertTrue(self.superuser.check_password(self.superuser_data['password']))
+        self.assertTrue(self.superuser.is_superuser)
+        self.assertTrue(self.superuser.is_staff)
+
+    def test_get_full_name(self):
+        """
+        Test the get_full_name method of the User model.
+        """
+        full_name = self.user.get_full_name()
+        expected_name = f'{self.user.name} {self.user.surname} ( {self.user.email} )'
+        self.assertEqual(full_name, expected_name)
+
+    def test_get_short_name(self):
+        """
+        Test the get_short_name method of the User model.
+        """
+        short_name = self.user.get_short_name()
+        expected_name = f'{self.user.name}{self.user.surname}'
+        self.assertEqual(short_name, expected_name)
+
+    def test_create_auth_token_signal(self):
+        """
+        Test the creation of an authentication token using a signal.
+        """
+        token = self.user.auth_token
+        self.assertIsNotNone(token)
+
+class UserSerializerTest(TestCase):
+    def setUp(self):
+        """
+        Set up test data for UserSerializer tests.
+        """
+        self.user_data = {
+            'email': 'test@example.com',
+            'name': 'John',
+            'surname': 'Doe',
+            'password': 'password123'
+        }
+
+    def test_valid_user_serializer_data(self):
+        """
+        Test the UserSerializer with valid data.
+        """
+        # Create a serializer instance with valid data
+        serializer = UserSerializer(data=self.user_data)
+        self.assertTrue(serializer.is_valid())
+        
+        # Check if the serializer saves the user correctly
+        user = serializer.save()
+        self.assertEqual(user.email, self.user_data['email'])
+        self.assertEqual(user.name, self.user_data['name'])
+        self.assertEqual(user.surname, self.user_data['surname'])
+
+        # Check if the user password is set correctly
+        self.assertTrue(user.check_password(self.user_data['password']))
+
+    def test_invalid_user_serializer_data(self):
+        """
+        Test the UserSerializer with invalid data.
+        """
+        # Create a serializer instance with invalid data
+        invalid_data = {
+            'email': 'invalid_email',
+            'name': '',
+            'surname': '',
+            'password': ''
+        }
+        serializer = UserSerializer(data=invalid_data)
+        self.assertFalse(serializer.is_valid())
+
+        # Check if serializer errors match the expected validation errors
+        expected_errors = {
+            'email': ['Enter a valid email address.'],
+            'name': ['This field may not be blank.'],
+            'surname': ['This field may not be blank.'],
+            'password': ['This field may not be blank.']
+        }
+        self.assertEqual(serializer.errors, expected_errors)
\ No newline at end of file

From d71023af779317b07100d95cd10403a3bb01ff43 Mon Sep 17 00:00:00 2001
From: szjaniak <szjaniak1@gmail.com>
Date: Wed, 31 Jan 2024 01:10:23 +0100
Subject: [PATCH 2/2] backend tests alignment

---
 backend/users/models.py                       |  8 +--
 .../users/{tests.py => test_user_model.py}    | 60 +------------------
 backend/users/test_user_serializer.py         | 55 +++++++++++++++++
 3 files changed, 60 insertions(+), 63 deletions(-)
 rename backend/users/{tests.py => test_user_model.py} (55%)
 create mode 100644 backend/users/test_user_serializer.py

diff --git a/backend/users/models.py b/backend/users/models.py
index fb78310..5bedf70 100644
--- a/backend/users/models.py
+++ b/backend/users/models.py
@@ -49,11 +49,11 @@ class User(AbstractBaseUser, PermissionsMixin):
     USERNAME_FIELD = 'email'
     REQUIRED_FIELDS = ['name', 'surname']
 
-    def get_full_name(self):
-        self.name + ' ' + self.surname + '( ' + self.email + ' )'
+    def get_full_name(self) -> str:
+        return self.name + ' ' + self.surname + ' ( ' + self.email + ' )'
 
-    def get_short_name(self):
-        self.name + self.surname
+    def get_short_name(self) -> str:
+        return self.name + self.surname
 
     def __str__(self):
         return self.email
diff --git a/backend/users/tests.py b/backend/users/test_user_model.py
similarity index 55%
rename from backend/users/tests.py
rename to backend/users/test_user_model.py
index 9c6b7ee..85c75b6 100644
--- a/backend/users/tests.py
+++ b/backend/users/test_user_model.py
@@ -1,9 +1,5 @@
 from django.test import TestCase
 
-# test.py
-
-# tests.py
-
 from django.contrib.auth import get_user_model
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.contrib.auth import get_user_model
@@ -11,8 +7,6 @@
 from django.contrib.auth import get_user_model
 from django.core import mail
 
-from backend.users.serializers import UserSerializer
-
 class UserModelTest(TestCase):
     def setUp(self):
         """
@@ -75,56 +69,4 @@ def test_create_auth_token_signal(self):
         Test the creation of an authentication token using a signal.
         """
         token = self.user.auth_token
-        self.assertIsNotNone(token)
-
-class UserSerializerTest(TestCase):
-    def setUp(self):
-        """
-        Set up test data for UserSerializer tests.
-        """
-        self.user_data = {
-            'email': 'test@example.com',
-            'name': 'John',
-            'surname': 'Doe',
-            'password': 'password123'
-        }
-
-    def test_valid_user_serializer_data(self):
-        """
-        Test the UserSerializer with valid data.
-        """
-        # Create a serializer instance with valid data
-        serializer = UserSerializer(data=self.user_data)
-        self.assertTrue(serializer.is_valid())
-        
-        # Check if the serializer saves the user correctly
-        user = serializer.save()
-        self.assertEqual(user.email, self.user_data['email'])
-        self.assertEqual(user.name, self.user_data['name'])
-        self.assertEqual(user.surname, self.user_data['surname'])
-
-        # Check if the user password is set correctly
-        self.assertTrue(user.check_password(self.user_data['password']))
-
-    def test_invalid_user_serializer_data(self):
-        """
-        Test the UserSerializer with invalid data.
-        """
-        # Create a serializer instance with invalid data
-        invalid_data = {
-            'email': 'invalid_email',
-            'name': '',
-            'surname': '',
-            'password': ''
-        }
-        serializer = UserSerializer(data=invalid_data)
-        self.assertFalse(serializer.is_valid())
-
-        # Check if serializer errors match the expected validation errors
-        expected_errors = {
-            'email': ['Enter a valid email address.'],
-            'name': ['This field may not be blank.'],
-            'surname': ['This field may not be blank.'],
-            'password': ['This field may not be blank.']
-        }
-        self.assertEqual(serializer.errors, expected_errors)
\ No newline at end of file
+        self.assertIsNotNone(token)
\ No newline at end of file
diff --git a/backend/users/test_user_serializer.py b/backend/users/test_user_serializer.py
new file mode 100644
index 0000000..b3590a4
--- /dev/null
+++ b/backend/users/test_user_serializer.py
@@ -0,0 +1,55 @@
+from django.test import TestCase
+
+from .serializers import UserSerializer
+
+class UserSerializerTest(TestCase):
+    def setUp(self):
+        """
+        Set up test data for UserSerializer tests.
+        """
+        self.user_data = {
+            'email': 'test@example.com',
+            'name': 'John',
+            'surname': 'Doe',
+            'password': 'password123'
+        }
+
+    def test_valid_user_serializer_data(self):
+        """
+        Test the UserSerializer with valid data.
+        """
+        # Create a serializer instance with valid data
+        serializer = UserSerializer(data=self.user_data)
+        self.assertTrue(serializer.is_valid())
+        
+        # Check if the serializer saves the user correctly
+        user = serializer.save()
+        self.assertEqual(user.email, self.user_data['email'])
+        self.assertEqual(user.name, self.user_data['name'])
+        self.assertEqual(user.surname, self.user_data['surname'])
+
+        # Check if the user password is set correctly
+        self.assertTrue(user.check_password(self.user_data['password']))
+
+    def test_invalid_user_serializer_data(self):
+        """
+        Test the UserSerializer with invalid data.
+        """
+        # Create a serializer instance with invalid data
+        invalid_data = {
+            'email': 'invalid_email',
+            'name': '',
+            'surname': '',
+            'password': ''
+        }
+        serializer = UserSerializer(data=invalid_data)
+        self.assertFalse(serializer.is_valid())
+
+        # Check if serializer errors match the expected validation errors
+        expected_errors = {
+            'email': ['Enter a valid email address.'],
+            'name': ['This field may not be blank.'],
+            'surname': ['This field may not be blank.'],
+            'password': ['This field may not be blank.']
+        }
+        self.assertEqual(serializer.errors, expected_errors)
\ No newline at end of file