tests/test_forms.py - main - oriono/taskman

tests/test_forms.py
561 строка20 KB
abo
Fix tests for invite code based team joining
17 май 2026, 02:37
17 май 2026, 02:374223597
from django.test import TestCase
from django.utils import timezone
from datetime import timedelta
from task_manager.user.models import User
from task_manager.teams.models import Team, TeamMembership, TeamInvite
from task_manager.user.forms import UserForm
from django.utils.translation import gettext as _


class UserFormTestCase(TestCase):
    fixtures = ["tests/fixtures/test_users.json",
                "tests/fixtures/test_teams.json",
                "tests/fixtures/test_teams_memberships.json",
                "tests/fixtures/test_tasks.json",
                "tests/fixtures/test_statuses.json",
                "tests/fixtures/test_labels.json"]

    def setUp(self):
        self.form_data = {
            'username': 'him',
            'password1': '12345678',
            'password2': '12345678',
        }

    def test_UserForm_valid(self):
        form = UserForm(data=self.form_data)
        self.assertTrue(form.is_valid())

    def test_create_user_description_not_in_form(self):
        """test that description field is not present on create form"""
        form = UserForm(data=self.form_data)
        self.assertNotIn('description', form.fields)

    def test_create_user_without_description(self):
        """test that user can be created without description"""
        form = UserForm(data=self.form_data)
        self.assertTrue(form.is_valid())
        user = form.save()
        self.assertEqual(user.description, '')

    def test_update_user_description(self):
        """test that user description can be updated"""
        user = User.objects.get(pk=10)  # me
        update_data = {
            'first_name': 'Updated',
            'last_name': 'User',
            'username': 'me',
            'description': 'New description for this user',
            'password1': '',
            'password2': '',
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=update_data, instance=user)
        self.assertTrue(form.is_valid())
        updated_user = form.save()
        self.assertEqual(
            updated_user.description,
            'New description for this user'
        )

    def test_update_user_clear_description(self):
        """test that user description can be cleared"""
        user = User.objects.get(pk=10)  # me - has description in fixture
        update_data = {
            'first_name': 'Updated',
            'last_name': 'User',
            'username': 'me',
            'description': '',
            'password1': '',
            'password2': '',
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=update_data, instance=user)
        self.assertTrue(form.is_valid())
        updated_user = form.save()
        self.assertEqual(updated_user.description, '')

    def test_create_user_without_password_fails(self):
        form_data = {
            'username': 'testuser',
            'password1': '',
            'password2': '',
        }
        form = UserForm(data=form_data)
        self.assertFalse(form.is_valid())
        # password fields required when create user
        self.assertIn('password1', form.errors)
        self.assertIn('password2', form.errors)

    def test_password_too_short(self):
        form_data = {
            'username': 'user',
            'password1': '1234567',
            'password2': '1234567'}
        form = UserForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn(_(
            'Your password is too short.'
            ' It must contain at least 8 characters.'),
            form.errors['password1'])

    def test_passwords_do_not_match(self):
        form_data = {
            'username': 'user',
            'password1': '12345678',
            'password2': '87654321'}
        form = UserForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn(
            _('The entered passwords do not match.'),
            form.errors['password2'])

    def test_save_user(self):
        form = UserForm(data=self.form_data)
        self.assertTrue(form.is_valid())
        user = form.save()
        self.assertIsInstance(user, User)
        self.assertTrue(user.check_password('12345678'))
        self.assertEqual(user.username, 'him')
        # Check user has no team memberships
        self.assertFalse(TeamMembership.objects.filter(user=user).exists())

    def test_join_team_via_invite_code(self):
        """Test new user joining team via invite code."""
        from task_manager.teams.models import TeamInvite
        from django.utils import timezone
        from datetime import timedelta

        team = Team.objects.get(pk=1)
        invite = TeamInvite.objects.create(
            team=team,
            created_by=User.objects.get(pk=10),
            max_uses=5,
            expires_at=timezone.now() + timedelta(days=30)
        )

        form_data = {
            'username': 'invite_user',
            'password1': '12345678',
            'password2': '12345678',
            'invite_code': str(invite.invite_code)
        }
        form = UserForm(data=form_data)
        self.assertTrue(form.is_valid())
        user = form.save()

        # Check membership was created with active status
        membership = TeamMembership.objects.get(user=user, team=team)
        self.assertEqual(membership.role, 'member')
        self.assertEqual(membership.status, 'active')
        # Check invite is marked as used
        invite.refresh_from_db()
        self.assertTrue(invite.is_used)
        self.assertEqual(invite.used_by, user)

    def test_join_team_without_password_fails_on_update(self):
        """test that joining team without password fails on update"""
        user = User.objects.get(pk=13)  # alone - no team
        team = Team.objects.get(pk=1)
        form_data = {
            'first_name': 'Updated',
            'last_name': 'User',
            'username': 'alone',
            'password1': '',
            'password2': '',
            'join_team_name': team.name,
            'join_team_password': ''  # No password
        }
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(_("Team password is required when joining a team"),
                      form.errors['__all__'])

    def test_nonexistent_team_name_on_update(self):
        """test that nonexistent team name fails on update"""
        user = User.objects.get(pk=13)
        form_data = {
            'first_name': 'Updated',
            'last_name': 'User',
            'username': 'alone',
            'password1': '',
            'password2': '',
            'join_team_name': 'Nonexistent Team',
            'join_team_password': 'somepassword'
        }
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(_("Team with this name does not exist"),
                      form.errors['__all__'])

    def test_wrong_team_password_on_update(self):
        """test that wrong team password fails on update"""
        user = User.objects.get(pk=13)
        team = Team.objects.get(pk=1)
        form_data = {
            'first_name': 'Updated',
            'last_name': 'User',
            'username': 'alone',
            'password1': '',
            'password2': '',
            'join_team_name': team.name,
            'join_team_password': 'wrongpassword'
        }
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(_("Invalid team password"), form.errors['__all__'])

    def test_update_user_shows_current_teams(self):
        # Get user with team membership
        user = User.objects.get(pk=10)  # me - has team membership
        form = UserForm(instance=user)

        # Check that current_teams field exists and is readonly
        self.assertIn('current_teams', form.fields)
        self.assertTrue('readonly' in form.fields['current_teams'].widget.attrs)

        # Check it shows correct team info
        expected_value = "Test Team (Admin), Another Test Team (Admin)"
        self.assertEqual(form.fields['current_teams'].initial, expected_value)

    def test_update_user_can_join_another_team(self):
        user = User.objects.get(pk=13)  # alone - no team
        new_team = Team.objects.get(pk=2)

        form_data = {
            'first_name': 'Updated',
            'last_name': 'User',
            'username': 'alone',
            'password1': '11111111',
            'password2': '11111111',
            'join_team_name': new_team.name,
            'join_team_password': (
                'pbkdf2_sha256$260000$abcdefghijklmnopqrstuvwxyz123456'
            )
        }
        form = UserForm(data=form_data, instance=user)
        self.assertTrue(form.is_valid())
        updated_user = form.save()

        # Check membership was created
        self.assertTrue(TeamMembership.objects.filter(
            user=updated_user, team=new_team).exists())

    def test_update_user_cannot_join_same_team_twice(self):
        user = User.objects.get(pk=10)  # me - already in Test Team
        team = Team.objects.get(pk=1)

        form_data = {
            'first_name': 'Updated',
            'last_name': 'User',
            'username': 'me',
            'password1': '',
            'password2': '',
            'join_team_name': team.name,
            'join_team_password': (
                'pbkdf2_sha256$260000$abcdefghijklmnopqrstuvwxyz123456'
            )
        }
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(_("You are already a member of this team"),
                      form.errors['__all__'])

    def test_update_user_without_password(self):
        user = User.objects.get(pk=10)
        old_password_hash = user.password

        form_data = {
            'first_name': 'Updated Me',
            'last_name': 'Updated M',
            'username': 'me',
            'password1': '',
            'password2': '',
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=form_data, instance=user)
        self.assertTrue(form.is_valid())
        updated_user = form.save()

        # Check that first_name was changed but not password
        self.assertEqual(updated_user.first_name, 'Updated Me')
        self.assertEqual(updated_user.password, old_password_hash)

    def test_update_user_with_new_password(self):
        user = User.objects.get(pk=10)
        old_password_hash = user.password

        form_data = {
            'first_name': 'Updated Me',
            'last_name': 'Updated M',
            'username': 'me',
            'password1': 'newpassword123',
            'password2': 'newpassword123',
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=form_data, instance=user)
        self.assertTrue(form.is_valid())
        updated_user = form.save()

        # Check that password was changed
        self.assertNotEqual(updated_user.password, old_password_hash)
        self.assertTrue(updated_user.check_password('newpassword123'))

    def test_update_user_only_one_password_field_filled(self):
        user = User.objects.get(pk=10)

        # Entered only password1
        form_data = {
            'first_name': 'Updated Me',
            'last_name': 'Updated M',
            'username': 'me',
            'password1': 'newpassword123',
            'password2': '',
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(
            _("Both password fields must be filled or both left blank"),
            form.errors['__all__']
        )

        # Entered only password2
        form_data['password1'] = ''
        form_data['password2'] = 'newpassword123'
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(
            _("Both password fields must be filled or both left blank"),
            form.errors['__all__']
        )

    def test_update_user_password_fields_not_required(self):
        user = User.objects.get(pk=10)
        form = UserForm(instance=user)

        self.assertFalse(form.fields['password1'].required)
        self.assertFalse(form.fields['password2'].required)
        self.assertEqual(
            form.fields['password1'].help_text,
            _("Leave blank if you don't want to change password")
        )
        self.assertEqual(
            form.fields['password2'].help_text,
            _("Leave blank if you don't want to change password")
        )

    def test_create_user_password_fields_required(self):
        form = UserForm()

        self.assertTrue(form.fields['password1'].required)
        self.assertTrue(form.fields['password2'].required)
        self.assertEqual(
            form.fields['password1'].help_text,
            _("Your password must contain at least 8 characters.")
        )
        self.assertEqual(
            form.fields['password2'].help_text,
            _("Please enter your password one more time")
        )

    def test_update_user_short_password_validation_applied(self):
        user = User.objects.get(pk=10)

        form_data = {
            'first_name': 'Updated Me',
            'last_name': 'Updated M',
            'username': 'me',
            'password1': '1234567',  # too short (7 chars)
            'password2': '1234567',
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(_(
            'Your password is too short.'
            ' It must contain at least 8 characters.'),
            form.errors['password1'])

    def test_update_user_passwords_mismatch_validation_works(self):
        user = User.objects.get(pk=10)

        form_data = {
            'first_name': 'Updated Me',
            'last_name': 'Updated M',
            'username': 'me',
            'password1': '12345678',
            'password2': '87654321',  # doesn't match
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=form_data, instance=user)
        self.assertFalse(form.is_valid())
        self.assertIn(
            _('The entered passwords do not match.'),
            form.errors['password2'])

    def test_pending_membership_shows_in_current_teams(self):
        """Test that pending membership is shown with 'Pending' status."""
        # Create teams for this test
        team1 = Team.objects.create(
            name='Active Test Team',
            description='Team with active membership',
            password='testpass123'
        )
        team2 = Team.objects.create(
            name='Pending Test Team',
            description='Team with pending membership',
            password='testpass456'
        )

        # Get user 13 (alone) who has no team memberships
        user = User.objects.get(pk=13)

        # Create an active membership
        # (required for current_teams field to appear)
        TeamMembership.objects.create(
            user=user,
            team=team1,
            role='member',
            status='active'
        )

        # Create a pending membership
        TeamMembership.objects.create(
            user=user,
            team=team2,
            role='member',
            status='pending'
        )

        # Form data for updating user
        form_data = {
            'first_name': user.first_name,
            'last_name': user.last_name,
            'username': user.username,
            'description': user.description,
            'password1': '',
            'password2': '',
            'join_team_name': '',
            'join_team_password': ''
        }
        form = UserForm(data=form_data, instance=user)

        # Check that current_teams field exists when updating user with teams
        self.assertIn('current_teams', form.fields)
        # Check it shows both active and pending status
        initial_value = form.fields['current_teams'].initial
        self.assertIn('Pending', initial_value)
        self.assertIn('Pending Test Team (Member) (Pending)', initial_value)
        self.assertIn('Active Test Team (Member)', initial_value)

    def test_join_team_via_used_invite_code(self):
        """Test that used invite code doesn't create membership."""
        team = Team.objects.get(pk=1)
        invite = TeamInvite.objects.create(
            team=team,
            created_by=User.objects.get(pk=10),
            max_uses=5,
            expires_at=timezone.now() + timedelta(days=30),
            is_used=True,
            used_by=User.objects.get(pk=10)
        )

        form_data = {
            'username': 'used_invite_user',
            'password1': '12345678',
            'password2': '12345678',
            'invite_code': str(invite.invite_code)
        }
        form = UserForm(data=form_data)
        self.assertTrue(form.is_valid())
        user = form.save()

        # Check no membership was created
        self.assertFalse(TeamMembership.objects.filter(
            user=user, team=team).exists())
        # Check user has default statuses (To Do, In Progress, etc.)
        self.assertTrue(user.created_statuses.exists())

    def test_join_team_via_expired_invite_code(self):
        """Test that expired invite code doesn't create membership."""
        team = Team.objects.get(pk=1)
        invite = TeamInvite.objects.create(
            team=team,
            created_by=User.objects.get(pk=10),
            max_uses=5,
            expires_at=timezone.now() - timedelta(days=1)  # Expired
        )

        form_data = {
            'username': 'expired_invite_user',
            'password1': '12345678',
            'password2': '12345678',
            'invite_code': str(invite.invite_code)
        }
        form = UserForm(data=form_data)
        self.assertTrue(form.is_valid())
        user = form.save()

        # Check no membership was created
        self.assertFalse(TeamMembership.objects.filter(
            user=user, team=team).exists())

    def test_join_team_via_max_uses_reached_invite(self):
        """Test invite with max uses reached doesn't create membership."""
        team = Team.objects.get(pk=1)
        invite = TeamInvite.objects.create(
            team=team,
            created_by=User.objects.get(pk=10),
            max_uses=1,
            use_count=1,
            expires_at=timezone.now() + timedelta(days=30),
            is_used=True
        )

        form_data = {
            'username': 'max_uses_user',
            'password1': '12345678',
            'password2': '12345678',
            'invite_code': str(invite.invite_code)
        }
        form = UserForm(data=form_data)
        self.assertTrue(form.is_valid())
        user = form.save()

        # Check no membership was created
        self.assertFalse(TeamMembership.objects.filter(
            user=user, team=team).exists())

    def test_join_team_via_invalid_uuid_invite_code(self):
        """Test invalid UUID invite code doesn't create membership."""
        # Handle ValidationError for invalid UUID
        from django.core.exceptions import ValidationError

        form_data = {
            'username': 'invalid_uuid_user',
            'password1': '12345678',
            'password2': '12345678',
            'invite_code': 'not-a-valid-uuid'
        }

        # Form should handle invalid UUID gracefully
        try:
            form = UserForm(data=form_data)
            # If form is valid, save should handle the invalid invite
            if form.is_valid():
                user = form.save()
                # Check no membership was created
                self.assertFalse(TeamMembership.objects.filter(
                    user=user).exists())
        except ValidationError:
            # Form validation should catch invalid UUID
            # User is still created without team membership
            pass