dj-tinyuser 0.0.1__py3-none-any.whl

dj_tinyuser/api/tests/test_user_api.py

@@ -0,0 +1,261 @@
+"""Tests for the tinyuser API."""
+
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.test import APIClient
+
+CREATE_USER_URL = reverse("tinyuser.api:user-create")
+TOKEN_URL = reverse("tinyuser.api:token")
+ME_URL = reverse("tinyuser.api:me")
+
+
+def create_user(**params):
+    """Create a new user with given parameters."""
+    return get_user_model().objects.create_user(**params)
+
+
+class PublicUserApiTests(TestCase):
+    """Tests the public features of the tinyuser user API."""
+
+    def setUp(self):
+        """Set up PublicUserApiTests."""
+        self.client = APIClient()
+        self.user_model = get_user_model()
+
+    def test_create_user_success(self):
+        """Test creating a user is successful."""
+        payload = {
+            "email": "test@example.com",
+            "password": "testpass123",
+            "username": "TestUser",
+        }
+        res = self.client.post(CREATE_USER_URL, payload, format="json")
+
+        self.assertEqual(res.status_code, status.HTTP_201_CREATED)
+        self.assertNotIn("password", res.data)
+
+        user = get_user_model().objects.get(email=payload["email"])
+
+        self.assertTrue(user.check_password(payload["password"]))
+
+    def test_create_user_with_existing_email_error(self):
+        """Test creating a user with an existing email fails."""
+        payload1 = {
+            "email": "test@example.com",
+            "password": "testpass123",
+            "username": "TestUser",
+        }
+        payload2 = {
+            "email": "test@example.com",
+            "password": "testpass456",
+            "username": "AnotherUser",
+        }
+
+        create_user(**payload1)
+        res = self.client.post(CREATE_USER_URL, payload2)
+
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_create_user_with_existing_username_error(self):
+        """Test creating a user with an existing username fails."""
+        payload1 = {
+            "email": "test@example.com",
+            "password": "testpass123",
+            "username": "TestUser",
+        }
+        payload2 = {
+            "email": "test2@example.com",
+            "password": "testpass456",
+            "username": "TestUser",
+        }
+
+        create_user(**payload1)
+        res = self.client.post(CREATE_USER_URL, payload2)
+
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_create_user_with_short_password_error(self):
+        """Test creating a user with a short password fails."""
+        payload = {
+            "email": "test@example.com",
+            "password": "pw",
+            "username": "TestUser",
+        }
+
+        res = self.client.post(CREATE_USER_URL, payload)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+        email_exists = get_user_model().objects.filter(email=payload["email"]).exists()
+        self.assertFalse(email_exists)
+
+    def test_create_user_with_missing_fields_error(self):
+        """Test creating a user with missing fields fails."""
+        payload1 = {
+            "email": "test@xeample.com",
+            "password": "testpass123",
+        }
+        payload2 = {
+            "username": "TestUser",
+            "password": "testpass123",
+        }
+        res1 = self.client.post(CREATE_USER_URL, payload1)
+        res2 = self.client.post(CREATE_USER_URL, payload2)
+
+        self.assertEqual(res1.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(res2.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_create_user_with_invalid_email_error(self):
+        """Test creating a user with an invalid email fails."""
+        payload = {
+            "email": "invalid-email",
+            "password": "testpass123",
+            "username": "TestUser",
+        }
+
+        res = self.client.post(CREATE_USER_URL, payload)
+
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_authentication_required_for_me_endpoint(self):
+        """Test that authentication is required for the me endpoint."""
+        res = self.client.get(ME_URL)
+
+        self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)
+
+
+class PrivateUserApiTests(TestCase):
+    """Tests the private features of the tinyuser user API."""
+
+    def setUp(self):
+        """Set up PrivateUserApiTests."""
+        self.user = create_user(
+            email="test@example.com",
+            password="testpass123",
+            username="TestUser",
+        )
+        self.client = APIClient()
+        self.client.force_authenticate(user=self.user)
+
+    def test_retrieve_user_profile_success(self):
+        """Test retrieving profile for logged in user."""
+        res = self.client.get(ME_URL)
+
+        self.assertEqual(res.status_code, status.HTTP_200_OK)
+        self.assertEqual(res.data["email"], self.user.email)
+        self.assertEqual(res.data["username"], self.user.username)
+        self.assertNotIn("password", res.data)
+
+    def test_post_me_not_allowed(self):
+        """Test that POST is not allowed on the me endpoint."""
+        res = self.client.post(ME_URL, {})
+        self.assertEqual(res.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
+
+    def test_patch_user_success(self):
+        """Test updating the user data for authenticated user."""
+        payload = {
+            "password": "newPassword123",
+            "username": "NewUsername",
+        }
+
+        res = self.client.patch(ME_URL, payload)
+        self.assertEqual(res.status_code, status.HTTP_200_OK)
+
+        self.user.refresh_from_db()
+
+        self.assertEqual(self.user.username, payload["username"])
+        # Password should not be updated here since it's not included in the response data
+        self.assertTrue(self.user.check_password(payload["password"]))
+
+        self.assertEqual(res.data["email"], self.user.email)
+        self.assertEqual(res.data["username"], self.user.username)
+        self.assertNotIn("password", res.data)
+
+    def test_patch_user_update_email_not_allowed(self):
+        """Test that updating the email is not allowed."""
+        payload = {"email": "new.email@example.com"}
+        res = self.client.patch(ME_URL, payload)
+        self.user.refresh_from_db()
+        self.assertEqual(self.user.email, "test@example.com")
+        self.assertEqual(res.status_code, status.HTTP_200_OK)
+
+    def test_patch_user_update_username_allowed(self):
+        """Test that updating the username is allowed."""
+        payload = {"username": "NewUsername"}
+        res = self.client.patch(ME_URL, payload)
+        self.user.refresh_from_db()
+        self.assertEqual(res.status_code, status.HTTP_200_OK)
+        self.assertEqual(res.data["username"], "NewUsername")
+
+
+class TokenAPITests(TestCase):
+    """Tests for the user authentication token API."""
+
+    def setUp(self):
+        """Set up TokenAPITests."""
+        self.client = APIClient()
+        self.user_model = get_user_model()
+
+    def test_create_token_for_user_valid_credentials(self):
+        """Test that a token is created for the user with valid credentials."""
+        payload = {
+            "email": "test@example.com",
+            "password": "testpass123",
+        }
+        create_user(email=payload["email"], password=payload["password"], username="TestUser")
+        res = self.client.post(TOKEN_URL, payload)
+
+        self.assertIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_200_OK)
+
+    def test_create_token_for_user_invalid_credentials(self):
+        """Test that a token is not created if invalid credentials are given."""
+        payload = {
+            "email": "test@example.com",
+            "password": "testpass123",
+        }
+        create_user(email=payload["email"], password=payload["password"], username="TestUser")
+
+        payload["password"] = "wrongpass"
+        res = self.client.post(TOKEN_URL, payload)
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+        payload["email"] = "nonexistent@example.com"
+        res = self.client.post(TOKEN_URL, payload)
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_create_token_for_user_missing_fields(self):
+        """Test that email and password are required to create a token."""
+        user_data = {
+            "email": "test@example.com",
+            "password": "testpass123",
+            "username": "TestUser",
+        }
+        create_user(**user_data)
+
+        res = self.client.post(TOKEN_URL, {"email": "", "password": ""})
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+        res = self.client.post(TOKEN_URL, {"email": user_data["email"], "password": ""})
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+        res = self.client.post(TOKEN_URL, {"email": "", "password": user_data["password"]})
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+        res = self.client.post(TOKEN_URL, {"password": user_data["password"]})
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+        res = self.client.post(TOKEN_URL, {"email": user_data["email"]})
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
+
+        res = self.client.post(TOKEN_URL, {})
+        self.assertNotIn("token", res.data)
+        self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)

dj_tinyuser/api/urls.py

@@ -0,0 +1,19 @@
+from django.urls import include, path
+from rest_framework.routers import DefaultRouter
+
+from . import views
+
+app_name = "tinyuser.api"
+
+router = DefaultRouter()
+# You can register your viewsets here, e.g.:
+# from .views import UserViewSet
+# router.register(r'users', UserViewSet)
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("accounts/create/", views.CreateUserView.as_view(), name="user-create"),
+    path("accounts/me/", views.ManageUserView.as_view(), name="me"),
+    path("accounts/token/", views.CreateTokenView.as_view(), name="token"),
+    path("accounts/invite/", views.InviteView.as_view(), name="invite"),
+]

dj_tinyuser/api/views.py

@@ -0,0 +1,65 @@
+"""Views for the user API."""
+
+from rest_framework import authentication, generics, permissions
+from rest_framework.authtoken.views import ObtainAuthToken
+from rest_framework.exceptions import PermissionDenied
+from rest_framework.settings import api_settings
+
+from dj_tinyuser import settings
+from dj_tinyuser.api.permissions import IsInvitor
+from dj_tinyuser.api.serializers import (  # UserProfileSerializer,
+    AuthTokenSerializer,
+    InvitationSerializer,
+    SafeUserSerializer,
+    UserSerializer,
+)
+
+# from django.contrib.auth import get_user_model
+
+
+class CreateUserView(generics.CreateAPIView):
+    """Create a new user in the system."""
+
+    #: serializer_class: The serializer class to use for validating
+    #: and deserializing input, and for serializing output.
+    serializer_class = UserSerializer
+
+    #: authentication_classes: The authentication classes to use for
+    #: this view. In this case, no authentication is required to create a user.
+    permission_classes = (permissions.AllowAny,)
+
+    def perform_create(self, serializer):
+        """Override the default create behavior to use the create_user method."""
+        if not settings.ALLOW_SIGNUP:
+            raise PermissionDenied("Signup is not allowed.")
+
+        super().perform_create(serializer)
+        serializer.save()
+
+
+class ManageUserView(generics.RetrieveUpdateDestroyAPIView):
+    """Manage the authenticated user."""
+
+    serializer_class = SafeUserSerializer
+    authentication_classes = (authentication.TokenAuthentication,)
+    permission_classes = (permissions.IsAuthenticated,)
+
+    def get_object(self):
+        """Retrieve and return the authenticated user."""
+        return self.request.user
+
+
+class CreateTokenView(ObtainAuthToken):
+    """Create a new auth token for user."""
+
+    serializer_class = AuthTokenSerializer
+    renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
+    permission_classes = (permissions.AllowAny,)
+
+
+class InviteView(generics.CreateAPIView):
+    """Invite a new user to the system."""
+
+    serializer_class = InvitationSerializer
+    renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
+    permission_classes = (IsInvitor,)

dj_tinyuser/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class DjangoTinyuserConfig(AppConfig):
+    name = "dj_tinyuser"
+    verbose_name = _("TinyUser")

dj_tinyuser/context_processors.py

@@ -0,0 +1,31 @@
+from dj_templates.theme import ThemeManager
+from django.http import HttpRequest
+
+# from django.utils.translation import gettext as _
+from dj_tinyuser import settings
+
+
+def tinyuser(request: HttpRequest):
+
+    theme = ThemeManager.get_global().get_theme(request=request)
+
+    try:
+        base_template = theme.get_template("base_template")
+    except LookupError:
+        base_template = theme.get_template("theme/base")
+
+    tinyuser_templates = {
+        "base_template": base_template,
+        "login_template": theme.get_template("tinyuser/account/login"),
+        "password_reset_template": theme.get_template("tinyuser/account/password_reset"),
+        "profile_template": theme.get_template("tinyuser/account/profile"),
+        "settings_template": theme.get_template("tinyuser/account/settings"),
+        "signup_template": theme.get_template("tinyuser/account/signup"),
+    }
+
+    return {
+        "socialaccount_enabled": settings.SOCIALACCOUNT_ENABLED,
+        "can_sign_up": settings.ALLOW_SIGNUP,
+        "invite_allow_all_authenticated_users": settings.INVITE_ALLOW_ALL_AUTHENTICATED_USERS,
+        "tinyuser_templates": tinyuser_templates,
+    }

dj_tinyuser/exceptions.py

@@ -0,0 +1,6 @@
+class FriendshipPending(Exception):
+    pass
+
+
+class FriendshipAlreadyExists(Exception):
+    pass

dj_tinyuser/forms.py

@@ -0,0 +1,96 @@
+from django import forms
+from django.core.files.images import ImageFile
+from django.core.files.uploadedfile import UploadedFile
+
+from dj_tinyuser.models import UserProfile, UserProfileSettings
+
+
+class ProfileForm(forms.ModelForm):
+    class Meta:
+        model = UserProfile
+        fields = [
+            "first_name",
+            "last_name",
+            "location",
+            "birth_date",
+            "website",
+            "mastodon_url",
+            "bio",
+        ]
+
+    def __init__(self, *args, **kwargs):
+        avatar_small = kwargs.pop("avatar_small", None)
+        avatar_medium = kwargs.pop("avatar_medium", None)
+        avatar_large = kwargs.pop("avatar_large", None)
+        avatar_full = kwargs.pop("avatar_full", None)
+
+        super().__init__(*args, **kwargs)
+
+        self.fields["avatar_small"] = forms.ImageField(
+            label="Avatar (Small)",
+            required=False,
+            widget=forms.ClearableFileInput(attrs={"accept": "image/*"}),
+            initial=avatar_small,
+        )
+
+        self.fields["avatar_medium"] = forms.ImageField(
+            label="Avatar (Medium)",
+            required=False,
+            widget=forms.ClearableFileInput(attrs={"accept": "image/*"}),
+            initial=avatar_medium,
+        )
+
+        self.fields["avatar_large"] = forms.ImageField(
+            label="Avatar (Large)",
+            required=False,
+            widget=forms.ClearableFileInput(attrs={"accept": "image/*"}),
+            initial=avatar_large,
+        )
+
+        self.fields["avatar_full"] = forms.ImageField(
+            label="Avatar (Full)",
+            required=False,
+            widget=forms.ClearableFileInput(attrs={"accept": "image/*"}),
+            initial=avatar_full,
+        )
+
+    def clean_avatar_small(self):
+        "print the uploaded file for debugging purposes"
+        avatar = self.cleaned_data.get("avatar_small")
+        if avatar and isinstance(avatar, UploadedFile):
+            if avatar.content_type not in ["image/jpeg", "image/png"]:
+                raise forms.ValidationError("Only JPEG and PNG images are allowed.")
+            if avatar.size > 2.5 * 1024 * 1024:  # Limit to 2.5MB
+                raise forms.ValidationError("Avatar file size must be under 2.5MB.")
+        elif avatar and not isinstance(avatar, ImageFile):
+            raise forms.ValidationError("Invalid file type for avatar.")
+
+        return avatar
+
+
+class ProfileSettingsForm(forms.ModelForm):
+    class Meta:
+        model = UserProfileSettings
+        fields = [
+            "is_enabled",
+            "key",
+            "show_avatar",
+            "show_email",
+            "show_full_name",
+            "show_birth_date",
+            "show_location",
+            "show_bio",
+            "show_mastodon_url",
+            "show_website",
+        ]
+
+
+class InviteForm(forms.Form):
+    email = forms.EmailField(label="Email", max_length=255)
+
+    def clean_email(self):
+        email = self.cleaned_data["email"]
+        # Check if the email is already associated with an existing user
+        if UserProfile.objects.filter(user__email=email).exists():
+            raise forms.ValidationError("A user with this email already exists.")
+        return email

dj_tinyuser/global_templates/__init__.py

@@ -0,0 +1,3 @@
+from pathlib import Path
+
+TEMPLATES_PATH = Path(__file__).resolve().parent

dj_tinyuser/global_templates/account/login.html

@@ -0,0 +1 @@
+{% extends tinyuser_templates.login_template %}

dj_tinyuser/global_templates/account/password_reset.html

@@ -0,0 +1 @@
+{% extends tinyuser_templates.password_reset_template %}

dj_tinyuser/global_templates/account/signup.html

@@ -0,0 +1 @@
+{% extends tinyuser_templates.signup_template %}

dj_tinyuser/global_templates/allauth/layouts/base.html

@@ -0,0 +1 @@
+{% extends base_template %}

dj_tinyuser/input_files/style.scss

@@ -0,0 +1,27 @@
+@import "../../node_modules/bootstrap/scss/bootstrap";
+// Update the import directory to point to it‘s location within node_modules
+$bootstrap-icons-font-dir: "../../node_modules/bootstrap-icons/font/fonts";
+
+// Import the Sass files as usual
+@import "../../node_modules/bootstrap-icons/font/bootstrap-icons";
+
+.login-card {
+    max-width: 400px;
+    background-color: $body-bg-dark;
+    color: $light-text-emphasis-dark;
+}
+
+.login-card .card-header {
+    background-color: $body-bg-dark;
+    color: $light-text-emphasis-dark;
+    text-align: center;
+    font-size: 1.5rem;
+    font-weight: bold;
+}
+
+.login-card .card-body {
+    padding: 2rem;
+    text-align: center;
+    color: $light-text-emphasis-dark;
+    background-color: $body-bg-dark;
+}