282 lines
10 KiB
Python
282 lines
10 KiB
Python
from unittest.mock import MagicMock, patch
|
|
|
|
from django.test import TestCase
|
|
from django.urls import reverse
|
|
from rest_framework import status
|
|
from rest_framework.test import APIClient, APITestCase
|
|
|
|
from torrent.models import Torrent
|
|
|
|
from .models import FriendRequest, Invitation, User
|
|
|
|
|
|
class UserModelTestCase(TestCase):
|
|
def setUp(self):
|
|
self.user = User.objects.create_user(
|
|
username="testuser",
|
|
email="test@example.com",
|
|
password="testpassword",
|
|
max_size=1000000,
|
|
)
|
|
self.friend = User.objects.create_user(
|
|
username="frienduser", email="friend@example.com", password="friendpassword"
|
|
)
|
|
|
|
def test_size_used_property(self):
|
|
"""Test the size_used property returns the correct total size of user's torrents"""
|
|
# Initially no torrents, so size should be 0
|
|
self.assertEqual(self.user.size_used, 0)
|
|
|
|
# Create a torrent for the user
|
|
Torrent.objects.create(
|
|
id="abc123",
|
|
name="Test Torrent",
|
|
user=self.user,
|
|
size=5000,
|
|
transmission_data={},
|
|
)
|
|
|
|
# Create another torrent
|
|
Torrent.objects.create(
|
|
id="def456",
|
|
name="Another Torrent",
|
|
user=self.user,
|
|
size=3000,
|
|
transmission_data={},
|
|
)
|
|
|
|
# Clear cached_property if it exists
|
|
if hasattr(self.user, "total_size"):
|
|
delattr(self.user, "total_size")
|
|
|
|
# Size used should be the sum of torrent sizes
|
|
self.assertEqual(self.user.size_used, 8000)
|
|
|
|
def test_min_infos_property(self):
|
|
"""Test the min_infos property returns the correct user info"""
|
|
expected_info = {"username": "testuser", "id": self.user.id}
|
|
self.assertEqual(self.user.min_infos, expected_info)
|
|
|
|
|
|
class UsernameUserManagerTestCase(TestCase):
|
|
def test_create_user(self):
|
|
"""Test creating a regular user"""
|
|
user = User.objects.create_user(
|
|
username="newuser", email="new@example.com", password="newpassword"
|
|
)
|
|
self.assertFalse(user.is_staff)
|
|
self.assertFalse(user.is_superuser)
|
|
self.assertEqual(user.username, "newuser")
|
|
self.assertEqual(user.email, "new@example.com")
|
|
self.assertTrue(user.check_password("newpassword"))
|
|
|
|
def test_create_superuser(self):
|
|
"""Test creating a superuser"""
|
|
admin = User.objects.create_superuser(
|
|
username="admin", email="admin@example.com", password="adminpassword"
|
|
)
|
|
self.assertTrue(admin.is_staff)
|
|
self.assertTrue(admin.is_superuser)
|
|
self.assertEqual(admin.username, "admin")
|
|
self.assertEqual(admin.email, "admin@example.com")
|
|
|
|
def test_create_user_without_username(self):
|
|
"""Test creating a user without username raises error"""
|
|
with self.assertRaises(ValueError):
|
|
User.objects.create_user(
|
|
username="", email="test@example.com", password="testpassword"
|
|
)
|
|
|
|
def test_create_user_without_email(self):
|
|
"""Test creating a user without email raises error"""
|
|
with self.assertRaises(ValueError):
|
|
User.objects.create_user(
|
|
username="testuser", email="", password="testpassword"
|
|
)
|
|
|
|
|
|
class FriendRequestModelTestCase(TestCase):
|
|
def setUp(self):
|
|
self.sender = User.objects.create_user(
|
|
username="sender", email="sender@example.com", password="senderpassword"
|
|
)
|
|
self.receiver = User.objects.create_user(
|
|
username="receiver",
|
|
email="receiver@example.com",
|
|
password="receiverpassword",
|
|
)
|
|
|
|
def test_friend_request_creation(self):
|
|
"""Test creating a friend request"""
|
|
friend_request = FriendRequest.objects.create(
|
|
sender=self.sender, receiver=self.receiver
|
|
)
|
|
self.assertEqual(friend_request.sender, self.sender)
|
|
self.assertEqual(friend_request.receiver, self.receiver)
|
|
|
|
def test_unique_together_constraint(self):
|
|
"""Test that the unique_together constraint works"""
|
|
FriendRequest.objects.create(sender=self.sender, receiver=self.receiver)
|
|
|
|
# Creating another request with the same sender and receiver should raise an error
|
|
with self.assertRaises(Exception):
|
|
FriendRequest.objects.create(sender=self.sender, receiver=self.receiver)
|
|
|
|
|
|
class InvitationModelTestCase(TestCase):
|
|
def setUp(self):
|
|
self.creator = User.objects.create_user(
|
|
username="creator", email="creator@example.com", password="creatorpassword"
|
|
)
|
|
|
|
def test_invitation_creation(self):
|
|
"""Test creating an invitation"""
|
|
invitation = Invitation.objects.create(created_by=self.creator)
|
|
self.assertEqual(invitation.created_by, self.creator)
|
|
self.assertIsNotNone(invitation.token)
|
|
self.assertIsNone(invitation.user)
|
|
|
|
def test_invitation_assignment(self):
|
|
"""Test assigning an invitation to a user"""
|
|
invitation = Invitation.objects.create(created_by=self.creator)
|
|
|
|
new_user = User.objects.create_user(
|
|
username="newuser", email="new@example.com", password="newpassword"
|
|
)
|
|
|
|
invitation.user = new_user
|
|
invitation.save()
|
|
|
|
# Refresh from database
|
|
invitation.refresh_from_db()
|
|
self.assertEqual(invitation.user, new_user)
|
|
|
|
|
|
class UserViewSetTestCase(APITestCase):
|
|
def setUp(self):
|
|
self.user = User.objects.create_user(
|
|
username="testuser", email="test@example.com", password="testpassword"
|
|
)
|
|
self.friend = User.objects.create_user(
|
|
username="frienduser", email="friend@example.com", password="friendpassword"
|
|
)
|
|
self.client = APIClient()
|
|
self.client.force_authenticate(user=self.user)
|
|
|
|
def test_list_users(self):
|
|
"""Test listing users"""
|
|
url = reverse("user-list")
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, status.HTTP_200_OK)
|
|
self.assertEqual(len(response.data), 2) # Should include both users
|
|
|
|
def test_retrieve_user(self):
|
|
"""Test retrieving a specific user"""
|
|
url = reverse("user-detail", args=[self.friend.id])
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, status.HTTP_200_OK)
|
|
self.assertEqual(response.data["username"], "frienduser")
|
|
|
|
def test_add_friend_request(self):
|
|
"""Test adding a friend request"""
|
|
url = reverse("user-add-friend-request", args=[self.friend.username])
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, status.HTTP_200_OK)
|
|
self.assertTrue(response.data["success"])
|
|
self.assertEqual(response.data["message"], "Request sent")
|
|
|
|
# Verify the friend request was created
|
|
self.assertTrue(
|
|
FriendRequest.objects.filter(
|
|
sender=self.user, receiver=self.friend
|
|
).exists()
|
|
)
|
|
|
|
def test_add_friend_request_nonexistent_user(self):
|
|
"""Test adding a friend request to a nonexistent user"""
|
|
url = reverse("user-add-friend-request", args=["nonexistentuser"])
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, status.HTTP_200_OK)
|
|
self.assertFalse(response.data["success"])
|
|
self.assertEqual(
|
|
response.data["message"], "User 'nonexistentuser' doesn't exist"
|
|
)
|
|
|
|
def test_remove_friend(self):
|
|
"""Test removing a friend"""
|
|
# First add as friend
|
|
self.user.friends.add(self.friend)
|
|
|
|
url = reverse("user-remove-friend", args=[self.friend.id])
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, status.HTTP_200_OK)
|
|
self.assertTrue(response.data["success"])
|
|
|
|
# Verify the friend was removed
|
|
self.assertFalse(self.user.friends.filter(id=self.friend.id).exists())
|
|
|
|
@patch("user.views.shutil.disk_usage")
|
|
def test_user_stats(self, mock_disk_usage):
|
|
"""Test getting user stats"""
|
|
# Mock disk_usage return value
|
|
mock_disk_usage.return_value = MagicMock(
|
|
total=1000000, used=500000, free=500000
|
|
)
|
|
|
|
# Create torrents for the user
|
|
Torrent.objects.create(
|
|
id="abc123",
|
|
name="Test Torrent",
|
|
user=self.user,
|
|
size=5000,
|
|
transmission_data={},
|
|
)
|
|
|
|
url = reverse("user-user-stats")
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, status.HTTP_200_OK)
|
|
|
|
# Check that the response contains the expected fields
|
|
self.assertIn("torrents_size", response.data)
|
|
self.assertIn("torrents_len", response.data)
|
|
self.assertIn("user_max_size", response.data)
|
|
self.assertIn("disk_total", response.data)
|
|
self.assertIn("disk_used", response.data)
|
|
self.assertIn("disk_free", response.data)
|
|
|
|
|
|
class FriendRequestViewSetTestCase(APITestCase):
|
|
def setUp(self):
|
|
self.user = User.objects.create_user(
|
|
username="testuser", email="test@example.com", password="testpassword"
|
|
)
|
|
self.sender = User.objects.create_user(
|
|
username="sender", email="sender@example.com", password="senderpassword"
|
|
)
|
|
self.client = APIClient()
|
|
self.client.force_authenticate(user=self.user)
|
|
|
|
# Create a friend request
|
|
self.friend_request = FriendRequest.objects.create(
|
|
sender=self.sender, receiver=self.user
|
|
)
|
|
|
|
def test_list_friend_requests(self):
|
|
"""Test listing friend requests"""
|
|
url = reverse("friendrequest-list")
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, status.HTTP_200_OK)
|
|
self.assertEqual(len(response.data), 1)
|
|
self.assertEqual(response.data[0]["sender"]["username"], "sender")
|
|
|
|
def test_delete_friend_request(self):
|
|
"""Test deleting a friend request"""
|
|
url = reverse("friendrequest-detail", args=[self.friend_request.id])
|
|
response = self.client.delete(url)
|
|
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
|
|
|
|
# Verify the friend request was deleted
|
|
self.assertFalse(
|
|
FriendRequest.objects.filter(id=self.friend_request.id).exists()
|
|
)
|