Neuread/Backend/NeureaAPI/neurea/api/tests.py

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase

from django.test import TestCase
from django.urls import reverse
from django.utils import timezone
from rest_framework import status
from rest_framework.test import APITestCase, APIClient
from access.models import User
from rest_framework_simplejwt.tokens import RefreshToken
from content.models import Metric

# region auth
class AuthenticationTests(APITestCase):
    def setUp(self):
        self.user = User.objects.create_user(name='testuser', email='test@example.com', password='testpassword')
        self.token_create_url = reverse('token_create')
        self.token_refresh_url = reverse('token_refresh')
        self.client = APIClient()

    # Позитивный сценарий создания токена с корректными данными пользователя
    def test_token_create_success(self):
        data = {'email': 'test@example.com', 'password': 'testpassword'}
        response = self.client.post(self.token_create_url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIn('access', response.data)
        self.assertIn('refresh', response.data)

    # Сценарий создания токена для пользователя с неверными данными (неправильный пароль)
    def test_token_create_failure_invalid_credentials(self):
        data = {'email': 'test@example.com', 'password': 'wrongpassword'}
        response = self.client.post(self.token_create_url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
        self.assertEqual(response.data['code'], 'no_active_account')

    # Позитивный сценарий получения обновления токенов
    def test_token_refresh_success(self):
        # Получение refresh-токена
        data = {'email': 'test@example.com', 'password': 'testpassword'}
        response = self.client.post(self.token_create_url, data, format='json')
        refresh_token = response.data['refresh']

        # Попытка обновления токена
        response = self.client.post(self.token_refresh_url, {'refresh': refresh_token}, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIn('access', response.data)
        self.assertIn('refresh', response.data)

    # Негативный сценарий: обновление токенов с неверно указанным refresh-токеном
    def test_token_refresh_failure_invalid_token(self):
        response = self.client.post(self.token_refresh_url, {'refresh': 'invalidtoken'}, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertEqual(response.data['code'], 'invalid_token')


class UserTests(APITestCase):
    def setUp(self):
        self.client = APIClient()
        self.create_user_url = reverse('create_user')  # Замените на правильный путь
        self.me_url = reverse('update_user')  # Замените на правильный путь

        # Создаем тестового пользователя
        self.test_user = User.objects.create_user(
            name='testuser',
            email='test@example.com',
            password='testpassword'
        )

        # Получаем JWT токен для тестового пользователя
        refresh = RefreshToken.for_user(self.test_user)
        self.access_token = str(refresh.access_token)

        # Устанавливаем токен в качестве аутентификационного заголовка
        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.access_token)

    def test_create_user(self):
        data = {
            'name': 'newuser',
            'email': 'new@example.com',
            'password': 'newpassword'
        }
        response = self.client.post(self.create_user_url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertIn('uuid', response.data)  # Проверяем, что ID возвращается в данных ответа

    def test_retrieve_user(self):
        response = self.client.get(self.me_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['name'], 'testuser')
        self.assertEqual(response.data['email'], 'test@example.com')

    def test_update_user(self):
        data = {
            'name': 'updated_user'
        }
        response = self.client.patch(self.me_url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['name'], 'updated_user')

    def test_delete_user(self):
        response = self.client.delete(self.me_url)
        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
        self.assertFalse(User.objects.filter(name='testuser').exists())

# endregion

# region metric
class MetricAPITest(APITestCase):

    def setUp(self):
        # Создание и аутентификация тестового пользователя
        self.user = User.objects.create_user(name='testuser', email='test@example.com', password='testpass')
        refresh = RefreshToken.for_user(self.user)
        self.jwt_token = str(refresh.access_token)
        self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.jwt_token)
        # Создание метрики для тестирования
        self.metric = Metric.objects.create(
            user=self.user,
            pages_read=100,
            reading_time="20:21:52",
            books_read=1
        )

    # Получение списка метрик
    def test_list_metrics_for_authenticated_user(self):
        url = reverse('metric_create')
        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertTrue(len(response.data) >= 1) # Полученный список должен содержать как минимум одну метрику

    # Создание корректно определенной метрики
    def test_create_metric_for_authenticated_user(self):
        url = reverse('metric_create')
        data = {
            'pages_read': 200,
            'reading_time': "20:21:52",
            'books_read': 2
        }
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

    # Получение конкретной метрики
    def test_retrieve_metric(self):
        url = reverse('metricme_rud', args=[self.metric.uuid])
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['pages_read'], self.metric.pages_read) # Проверка получения корректной метрики по атрибуту pages_read

    # Обновление метрики
    def test_update_metric(self):
        url = reverse('metricme_rud', args=[self.metric.uuid])
        data = {
            'pages_read': 150
        }
        response = self.client.patch(url, data, format='json')

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.metric.refresh_from_db()
        self.assertEqual(self.metric.pages_read, 150) # Проверка, поменялось ли значение на заданное


    # Удаление метрики
    def test_delete_metric(self):
        url = reverse('metricme_rud', args=[self.metric.uuid])
        response = self.client.delete(url)

        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
        self.assertEqual(Metric.objects.count(), 0) # Количество метрик должно стать 0

    # Проверка фильтрации метрик по дате
    def test_date_filtered_metrics(self):
        url = reverse('date_metrics')
        data = {
            'start_date': (timezone.now() - timezone.timedelta(days=1)).isoformat(),
            'end_date': timezone.now().isoformat()
        }
        response = self.client.get(url, data)

        self.assertEqual(response.status_code, status.HTTP_200_OK)