id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
17,400
|
0007_auto_20170219_1639.py
|
rafalp_Misago/misago/users/migrations/0007_auto_20170219_1639.py
|
# Generated by Django 1.10.5 on 2017-02-19 16:39
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_users", "0006_update_settings")]
operations = [
migrations.AlterField(
model_name="user",
name="limits_private_thread_invites_to",
field=models.PositiveIntegerField(
choices=[(0, "Everybody"), (1, "Users I follow"), (2, "Nobody")],
default=0,
),
),
migrations.AlterField(
model_name="user",
name="subscribe_to_replied_threads",
field=models.PositiveIntegerField(
choices=[(0, "No"), (1, "Notify"), (2, "Notify with e-mail")], default=0
),
),
migrations.AlterField(
model_name="user",
name="subscribe_to_started_threads",
field=models.PositiveIntegerField(
choices=[(0, "No"), (1, "Notify"), (2, "Notify with e-mail")], default=0
),
),
]
| 1,062
|
Python
|
.py
| 28
| 27.25
| 88
| 0.545102
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,401
|
0008_ban_registration_only.py
|
rafalp_Misago/misago/users/migrations/0008_ban_registration_only.py
|
# Generated by Django 1.10.5 on 2017-03-04 22:06
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_users", "0007_auto_20170219_1639")]
operations = [
migrations.AddField(
model_name="ban",
name="registration_only",
field=models.BooleanField(db_index=True, default=False),
),
migrations.AlterField(
model_name="ban",
name="check_type",
field=models.PositiveIntegerField(
choices=[(0, "Username"), (1, "E-mail address"), (2, "IP address")],
db_index=True,
default=0,
),
),
]
| 707
|
Python
|
.py
| 20
| 25.4
| 84
| 0.562865
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,402
|
0002_users_settings.py
|
rafalp_Misago/misago/users/migrations/0002_users_settings.py
|
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_users", "0001_initial"), ("misago_conf", "0001_initial")]
operations = []
| 182
|
Python
|
.py
| 4
| 41.75
| 86
| 0.72
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,403
|
0027_new_permissions.py
|
rafalp_Misago/misago/users/migrations/0027_new_permissions.py
|
# Generated by Django 4.2.7 on 2023-12-21 21:10
import django.contrib.postgres.fields
import django.contrib.postgres.indexes
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0026_plugin_data"),
]
operations = [
migrations.CreateModel(
name="Group",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("name", models.CharField(max_length=150)),
("slug", models.CharField(max_length=150, unique=True)),
("user_title", models.CharField(blank=True, max_length=150, null=True)),
("color", models.CharField(blank=True, max_length=7, null=True)),
("icon", models.CharField(blank=True, max_length=50, null=True)),
("css_suffix", models.CharField(blank=True, max_length=50, null=True)),
("is_page", models.BooleanField(default=False)),
("is_hidden", models.BooleanField(default=False)),
("is_default", models.BooleanField(default=False)),
("ordering", models.PositiveIntegerField(default=0)),
("can_use_private_threads", models.BooleanField(default=False)),
("can_start_private_threads", models.BooleanField(default=False)),
("private_thread_users_limit", models.PositiveIntegerField(default=1)),
("can_change_username", models.BooleanField(default=False)),
("username_changes_limit", models.PositiveIntegerField(default=0)),
("username_changes_expire", models.PositiveIntegerField(default=0)),
("username_changes_span", models.PositiveIntegerField(default=0)),
("can_see_user_profiles", models.BooleanField(default=False)),
("plugin_data", models.JSONField(default=dict)),
],
options={"ordering": ["ordering"]},
),
migrations.AddIndex(
model_name="group",
index=django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_user_plugin__e41d7b_gin"
),
),
migrations.AddField(
model_name="user",
name="groups_ids",
field=django.contrib.postgres.fields.ArrayField(
base_field=models.PositiveIntegerField(), default=list, size=None
),
),
migrations.AddIndex(
model_name="user",
index=django.contrib.postgres.indexes.GinIndex(
fields=["groups_ids"], name="misago_user_groups_ids"
),
),
migrations.AddField(
model_name="user",
name="group",
field=models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.PROTECT,
to="misago_users.group",
),
),
migrations.AddField(
model_name="user",
name="permissions_id",
field=models.CharField(blank=True, max_length=16, null=True),
),
migrations.AddField(
model_name="user",
name="is_misago_root",
field=models.BooleanField(default=False),
),
migrations.AddIndex(
model_name="user",
index=models.Index(
condition=models.Q(("is_misago_root", True)),
fields=["is_misago_root"],
name="misago_user_is_misago_root",
),
),
migrations.CreateModel(
name="GroupDescription",
fields=[
(
"group",
models.OneToOneField(
on_delete=django.db.models.deletion.PROTECT,
primary_key=True,
related_name="description",
serialize=False,
to="misago_users.group",
),
),
("markdown", models.TextField(blank=True, null=True)),
("html", models.TextField(blank=True, null=True)),
("meta", models.TextField(blank=True, null=True)),
("plugin_data", models.JSONField(default=dict)),
],
options={
"abstract": False,
"indexes": [
django.contrib.postgres.indexes.GinIndex(
fields=["plugin_data"], name="misago_user_plugin__065d95_gin"
)
],
},
),
]
| 4,935
|
Python
|
.py
| 119
| 27.058824
| 88
| 0.516833
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,404
|
0004_default_ranks.py
|
rafalp_Misago/misago/users/migrations/0004_default_ranks.py
|
from django.db import migrations
from ...core.utils import slugify
pgettext_lazy = lambda c, s: s
def create_default_ranks(apps, schema_editor):
Rank = apps.get_model("misago_users", "Rank")
team = Rank.objects.create(
name=pgettext_lazy("rank name", "Forum team"),
slug=slugify(pgettext_lazy("rank name", "Forum team")),
title=pgettext_lazy("rank name", "Team"),
css_class="primary",
is_tab=True,
order=0,
)
member = Rank.objects.create(
name=pgettext_lazy("rank name", "Members"),
slug=slugify(pgettext_lazy("rank name", "Members")),
is_default=True,
order=1,
)
Role = apps.get_model("misago_acl", "Role")
team.roles.add(Role.objects.get(name=pgettext_lazy("role name", "Moderator")))
team.roles.add(Role.objects.get(name=pgettext_lazy("role name", "Private threads")))
team.roles.add(
Role.objects.get(name=pgettext_lazy("role name", "Private threads moderator"))
)
team.roles.add(Role.objects.get(name=pgettext_lazy("role name", "Deleting users")))
member.roles.add(
Role.objects.get(name=pgettext_lazy("role name", "Private threads"))
)
class Migration(migrations.Migration):
dependencies = [
("misago_users", "0003_bans_version_tracker"),
("misago_acl", "0003_default_roles"),
]
operations = [migrations.RunPython(create_default_ranks)]
| 1,431
|
Python
|
.py
| 35
| 34.514286
| 88
| 0.658237
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,405
|
0013_auto_20180609_1523.py
|
rafalp_Misago/misago/users/migrations/0013_auto_20180609_1523.py
|
# Generated by Django 1.11.13 on 2018-06-09 15:23
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("misago_users", "0012_audittrail")]
operations = [
migrations.RemoveField(model_name="online", name="current_ip"),
migrations.RemoveField(model_name="user", name="last_ip"),
migrations.AlterField(
model_name="user",
name="joined_from_ip",
field=models.GenericIPAddressField(blank=True, null=True),
),
]
| 533
|
Python
|
.py
| 13
| 33.615385
| 71
| 0.659574
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,406
|
profile.py
|
rafalp_Misago/misago/users/views/profile.py
|
from django.contrib.auth import get_user_model
from django.http import Http404
from django.shortcuts import get_object_or_404, redirect, render
from django.views import View
from ...acl.objectacl import add_acl_to_obj
from ...core.shortcuts import paginate, pagination_dict, validate_slug
from ..bans import get_user_ban
from ..online.utils import get_user_status
from ..pages import user_profile
from ..profilefields import profilefields, serialize_profilefields_data
from ..serializers import BanDetailsSerializer, UsernameChangeSerializer, UserSerializer
from ..viewmodels import Followers, Follows, UserPosts, UserThreads
User = get_user_model()
class ProfileView(View):
def get(self, request, *args, **kwargs):
profile = self.get_profile(request, kwargs.pop("pk"), kwargs.pop("slug"))
# resolve that we can display requested section
sections = user_profile.get_sections(request, profile)
active_section = self.get_active_section(sections)
if not active_section:
raise Http404()
profile.status = get_user_status(request, profile)
context_data = self.get_context_data(request, profile)
self.complete_frontend_context(request, profile, sections)
self.complete_context_data(request, profile, sections, context_data)
return render(request, self.template_name, context_data)
def get_profile(self, request, pk, slug):
queryset = User.objects.select_related("rank", "online_tracker", "ban_cache")
profile = get_object_or_404(queryset, pk=pk)
if not profile.is_active and not request.user.is_misago_admin:
raise Http404()
validate_slug(profile, slug)
add_acl_to_obj(request.user_acl, profile)
return profile
def get_active_section(self, sections):
for section in sections:
if section["is_active"]:
return section
def get_context_data(self, request, profile):
return {}
def complete_frontend_context(self, request, profile, sections):
request.frontend_context["PROFILE_PAGES"] = []
for section in sections:
request.frontend_context["PROFILE_PAGES"].append(
{
"name": str(section["name"]),
"icon": section["icon"],
"meta": section.get("metadata"),
"component": section["component"],
}
)
request.frontend_context["PROFILE"] = UserProfileSerializer(
profile, context={"request": request}
).data
if not profile.is_active:
request.frontend_context["PROFILE"]["is_active"] = False
if profile.is_deleting_account:
request.frontend_context["PROFILE"]["is_deleting_account"] = True
def complete_context_data(self, request, profile, sections, context):
context["profile"] = profile
context["sections"] = sections
for section in sections:
if section["is_active"]:
context["active_section"] = section
break
if request.user.is_authenticated:
is_authenticated_user = profile.pk == request.user.pk
context.update(
{
"is_authenticated_user": is_authenticated_user,
"show_email": is_authenticated_user,
}
)
if not context["show_email"]:
context["show_email"] = request.user_acl["can_see_users_emails"]
else:
context.update({"is_authenticated_user": False, "show_email": False})
class LandingView(ProfileView):
def get(self, request, *args, **kwargs):
profile = self.get_profile(request, kwargs.pop("pk"), kwargs.pop("slug"))
return redirect(
user_profile.get_default_link(), slug=profile.slug, pk=profile.pk
)
class UserPostsView(ProfileView):
template_name = "misago/profile/posts.html"
def get_context_data(self, request, profile):
feed = UserPosts(request, profile)
request.frontend_context["POSTS"] = feed.get_frontend_context()
return feed.get_template_context()
class UserThreadsView(ProfileView):
template_name = "misago/profile/threads.html"
def get_context_data(self, request, profile):
feed = UserThreads(request, profile)
request.frontend_context["POSTS"] = feed.get_frontend_context()
return feed.get_template_context()
class UserFollowersView(ProfileView):
template_name = "misago/profile/followers.html"
def get_context_data(self, request, profile):
users = Followers(request, profile)
request.frontend_context["PROFILE_FOLLOWERS"] = users.get_frontend_context()
return users.get_template_context()
class UserFollowsView(ProfileView):
template_name = "misago/profile/follows.html"
def get_context_data(self, request, profile):
users = Follows(request, profile)
request.frontend_context["PROFILE_FOLLOWS"] = users.get_frontend_context()
return users.get_template_context()
class UserProfileDetailsView(ProfileView):
template_name = "misago/profile/details.html"
def get_context_data(self, request, profile):
details = serialize_profilefields_data(request, profilefields, profile)
request.frontend_context["PROFILE_DETAILS"] = details
return {"profile_details": details}
class UserUsernameHistoryView(ProfileView):
template_name = "misago/profile/username_history.html"
def get_context_data(self, request, profile):
queryset = profile.namechanges.select_related("user", "changed_by")
queryset = queryset.order_by("-id")
page = paginate(queryset, None, 14, 4)
data = pagination_dict(page)
data.update(
{"results": UsernameChangeSerializer(page.object_list, many=True).data}
)
request.frontend_context["PROFILE_NAME_HISTORY"] = data
return {"history": page.object_list, "count": data["count"]}
class UserBanView(ProfileView):
template_name = "misago/profile/ban_details.html"
def get_context_data(self, request, profile):
ban = get_user_ban(profile, request.cache_versions)
request.frontend_context["PROFILE_BAN"] = BanDetailsSerializer(ban).data
return {"ban": ban}
UserProfileSerializer = UserSerializer.subset_fields(
"id",
"username",
"slug",
"email",
"joined_on",
"rank",
"title",
"avatars",
"is_avatar_locked",
"signature",
"is_signature_locked",
"followers",
"following",
"threads",
"posts",
"acl",
"is_followed",
"is_blocked",
"real_name",
"status",
"api",
"url",
)
| 6,799
|
Python
|
.py
| 155
| 35.529032
| 88
| 0.660033
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,407
|
forgottenpassword.py
|
rafalp_Misago/misago/users/views/forgottenpassword.py
|
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404, render
from django.urls import reverse
from django.utils.translation import pgettext
from ...core.exceptions import Banned
from ..bans import get_user_ban
from ..decorators import deny_banned_ips
from ..tokens import is_password_change_token_valid
@deny_banned_ips
def request_reset(request):
if request.settings.enable_oauth2_client:
raise PermissionDenied(
pgettext("user password", "Please use %(provider)s to reset your password.")
% {"provider": request.settings.oauth2_provider}
)
request.frontend_context.update(
{"SEND_PASSWORD_RESET_API": reverse("misago:api:send-password-form")}
)
return render(request, "misago/forgottenpassword/request.html")
class ResetError(Exception):
pass
@deny_banned_ips
def reset_password_form(request, pk, token):
if request.settings.enable_oauth2_client:
raise PermissionDenied(
pgettext("user password", "Please use %(provider)s to reset your password.")
% {"provider": request.settings.oauth2_provider}
)
requesting_user = get_object_or_404(get_user_model(), pk=pk)
try:
if request.user.is_authenticated and request.user.id != requesting_user.id:
message = pgettext(
"user password",
"%(user)s, your link has expired. Please request new link and try again.",
)
raise ResetError(message % {"user": requesting_user.username})
if not is_password_change_token_valid(requesting_user, token):
message = pgettext(
"user password",
"%(user)s, your link is invalid. Please try again or request new link.",
)
raise ResetError(message % {"user": requesting_user.username})
ban = get_user_ban(requesting_user, request.cache_versions)
if ban:
raise Banned(ban)
except ResetError as e:
return render(
request,
"misago/forgottenpassword/error.html",
{"message": e.args[0]},
status=400,
)
api_url = reverse(
"misago:api:change-forgotten-password", kwargs={"pk": pk, "token": token}
)
request.frontend_context["CHANGE_PASSWORD_API"] = api_url
return render(request, "misago/forgottenpassword/form.html")
| 2,481
|
Python
|
.py
| 58
| 34.775862
| 90
| 0.664176
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,408
|
activation.py
|
rafalp_Misago/misago/users/views/activation.py
|
from django.core.exceptions import PermissionDenied
from django.contrib.auth import get_user_model
from django.shortcuts import get_object_or_404, render
from django.urls import reverse
from django.utils.translation import pgettext
from ...core.exceptions import Banned
from ..bans import get_user_ban
from ..decorators import deny_authenticated, deny_banned_ips
from ..tokens import is_activation_token_valid
User = get_user_model()
def activation_view(f):
@deny_authenticated
@deny_banned_ips
def decorator(request, *args, **kwargs):
if request.settings.enable_oauth2_client:
raise PermissionDenied(
pgettext(
"activate account",
"Please use %(provider)s to activate your account.",
)
% {"provider": request.settings.oauth2_provider}
)
return f(request, *args, **kwargs)
return decorator
@activation_view
def request_activation(request):
request.frontend_context.update(
{"SEND_ACTIVATION_API": reverse("misago:api:send-activation")}
)
return render(request, "misago/activation/request.html")
class ActivationStopped(Exception):
pass
class ActivationError(Exception):
pass
@activation_view
def activate_by_token(request, pk, token):
inactive_user = get_object_or_404(User, pk=pk, is_active=True)
try:
if not inactive_user.requires_activation:
message = pgettext(
"activate account with token",
"%(user)s, your account is already active.",
)
raise ActivationStopped(message % {"user": inactive_user.username})
if not is_activation_token_valid(inactive_user, token):
message = pgettext(
"activate account with token",
"%(user)s, your activation link is invalid. Try again or request new activation link.",
)
raise ActivationError(message % {"user": inactive_user.username})
ban = get_user_ban(inactive_user, request.cache_versions)
if ban:
raise Banned(ban)
except ActivationStopped as e:
return render(request, "misago/activation/stopped.html", {"message": e.args[0]})
except ActivationError as e:
return render(
request, "misago/activation/error.html", {"message": e.args[0]}, status=400
)
inactive_user.requires_activation = User.ACTIVATION_NONE
inactive_user.save(update_fields=["requires_activation"])
message = pgettext(
"activate account with token", "%(user)s, your account has been activated!"
)
return render(
request,
"misago/activation/done.html",
{"message": message % {"user": inactive_user.username}},
)
| 2,799
|
Python
|
.py
| 69
| 32.608696
| 103
| 0.661993
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,409
|
auth.py
|
rafalp_Misago/misago/users/views/auth.py
|
from django.conf import settings
from django.contrib import auth
from django.shortcuts import redirect
from django.views.decorators.cache import never_cache
from django.views.decorators.csrf import csrf_protect
@never_cache
@csrf_protect
def logout(request):
if request.method == "POST" and request.user.is_authenticated:
auth.logout(request)
return redirect(settings.LOGIN_REDIRECT_URL)
| 406
|
Python
|
.py
| 11
| 34.272727
| 66
| 0.814249
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,410
|
lists.py
|
rafalp_Misago/misago/users/views/lists.py
|
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
from django.views import View
from ...core.utils import format_plaintext_for_html
from ..models import Rank
from ..pages import users_list
from ..permissions import allow_browse_users_list
from ..viewmodels import ActivePosters, RankUsers
class ListView(View):
def get(self, request, *args, **kwargs):
allow_browse_users_list(request.user_acl)
context_data = self.get_context_data(request, *args, **kwargs)
sections = users_list.get_sections(request)
context_data["pages"] = sections
request.frontend_context["USERS_LISTS"] = []
for page in sections:
page["reversed_link"] = reverse(page["link"])
request.frontend_context["USERS_LISTS"].append(
{"name": str(page["name"]), "component": page["component"]}
)
active_rank = context_data.get("rank")
for rank in Rank.objects.filter(is_tab=True).order_by("order"):
context_data["pages"].append(
{
"name": str(rank),
"reversed_link": reverse(
"misago:users-rank", kwargs={"slug": rank.slug}
),
"is_active": active_rank.pk == rank.pk if active_rank else None,
}
)
if rank.description:
description = {
"plain": rank.description,
"html": format_plaintext_for_html(rank.description),
}
else:
description = None
request.frontend_context["USERS_LISTS"].append(
{
"id": rank.pk,
"name": str(rank),
"slug": rank.slug,
"css_class": rank.css_class,
"description": description,
"component": "rank",
}
)
active_section = list(filter(lambda x: x["is_active"], sections))[0]
context_data["active_section"] = active_section
return render(request, self.template_name, context_data)
def get_context_data(self, request, *args, **kwargs):
return {}
def landing(request):
allow_browse_users_list(request.user_acl)
return redirect(users_list.get_default_link())
class ActivePostersView(ListView):
template_name = "misago/userslists/active_posters.html"
def get_context_data(self, request, *args, **kwargs):
model = ActivePosters(request)
request.frontend_context["USERS"] = model.get_frontend_context()
return model.get_template_context()
class RankUsersView(ListView):
template_name = "misago/userslists/rank.html"
def get_context_data(self, request, slug, page=0):
rank = get_object_or_404(Rank.objects.filter(is_tab=True), slug=slug)
users = RankUsers(request, rank, page)
request.frontend_context["USERS"] = users.get_frontend_context()
context = {"rank": rank}
context.update(users.get_template_context())
return context
| 3,172
|
Python
|
.py
| 71
| 33.450704
| 84
| 0.592846
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,411
|
avatarserver.py
|
rafalp_Misago/misago/users/views/avatarserver.py
|
from django.contrib.auth import get_user_model
from django.shortcuts import redirect
from django.templatetags.static import static
from ...conf import settings
User = get_user_model()
def user_avatar(request, pk, size):
size = int(size)
try:
user = User.objects.get(pk=pk)
except User.DoesNotExist:
return blank_avatar(request)
found_avatar = user.avatars[0]
for avatar in user.avatars:
if avatar["size"] >= size:
found_avatar = avatar
return redirect(found_avatar["url"])
def blank_avatar(request):
return redirect(
request.settings.blank_avatar or static(settings.MISAGO_BLANK_AVATAR)
)
| 673
|
Python
|
.py
| 20
| 28.45
| 77
| 0.710078
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,412
|
basefields.py
|
rafalp_Misago/misago/users/profilefields/basefields.py
|
from django import forms
from django.db.models import Q
from django.utils import html
from ...core.utils import format_plaintext_for_html
__all__ = [
"ProfileField",
"TextProfileField",
"UrlProfileField",
"TextareaProfileField",
"ChoiceProfileField",
]
class ProfileField:
"""
Basic profile field
"""
fieldname = None
label = None
help_text = None
readonly = False
def is_editable(self, request, user):
return not self.readonly
def get_label(self, user):
if not self.label:
raise NotImplementedError(
"profile field class has to define label "
"attribute or get_label(user) method"
)
return self.label
def get_help_text(self, user):
return self.help_text
def get_form_field(self, request, user):
return None
def get_form_field_json(self, request, user):
return {
"fieldname": self.fieldname,
"label": self.get_label(user),
"help_text": self.get_help_text(user),
"initial": user.profile_fields.get(self.fieldname, ""),
"input": self.get_input_json(request, user),
}
def get_input_json(self, request, user):
return None
def clean(self, request, user, data):
return data
def get_display_data(self, request, user):
value = user.profile_fields.get(self.fieldname, "").strip()
if not self.readonly and not value:
return None
data = self.get_value_display_data(request, user, value)
if not data:
return None
data.update({"fieldname": self.fieldname, "name": str(self.get_label(user))})
return data
def get_value_display_data(self, request, user, value):
return {"text": value}
def search_users(self, criteria):
if self.readonly:
return None
return Q(**{"profile_fields__%s__contains" % self.fieldname: criteria})
class ChoiceProfileField(ProfileField):
choices = None
def get_choices(self, user=None):
if not self.choices:
raise NotImplementedError(
"profile field ChoiceProfileField has to define "
"choices attribute or get_choices(user) method"
)
return self.choices
def get_form_field(self, request, user):
return forms.ChoiceField(
label=self.get_label(user),
help_text=self.get_help_text(user),
initial=user.profile_fields.get(self.fieldname),
choices=self.get_choices(user),
widget=forms.RadioSelect(),
disabled=self.readonly,
required=False,
)
def get_input_json(self, request, user):
choices = []
for key, choice in self.get_choices(): # pylint: disable=not-an-iterable
choices.append({"value": key, "label": choice})
return {"type": "select", "choices": choices}
def get_value_display_data(self, request, user, value):
for key, name in self.get_choices(): # pylint: disable=not-an-iterable
if key == value:
return {"text": str(name)}
def search_users(self, criteria):
"""custom search implementation for choice fields"""
q_obj = Q(**{"profile_fields__%s__contains" % self.fieldname: criteria})
for key, choice in self.get_choices(): # pylint: disable=not-an-iterable
if key and criteria.lower() in str(choice).lower():
q_obj = q_obj | Q(**{"profile_fields__%s" % self.fieldname: key})
return q_obj
class TextProfileField(ProfileField):
def get_form_field(self, request, user):
return forms.CharField(
label=self.get_label(user),
help_text=self.get_help_text(user),
initial=user.profile_fields.get(self.fieldname),
max_length=250,
disabled=self.readonly,
required=False,
)
def get_input_json(self, request, user):
return {"type": "text"}
class TextareaProfileField(ProfileField):
def get_form_field(self, request, user):
return forms.CharField(
label=self.get_label(user),
help_text=self.get_help_text(user),
initial=user.profile_fields.get(self.fieldname),
max_length=500,
widget=forms.Textarea(attrs={"rows": 4}),
disabled=self.readonly,
required=False,
)
def get_input_json(self, request, user):
return {"type": "textarea"}
def get_value_display_data(self, request, user, value):
return {"html": html.linebreaks(html.escape(value))}
class UrlifiedTextareaProfileField(TextareaProfileField):
def get_value_display_data(self, request, user, value):
return {"html": format_plaintext_for_html(value)}
class UrlProfileField(TextProfileField):
def get_form_field(self, request, user):
return forms.URLField(
label=self.get_label(user),
help_text=self.get_help_text(user),
initial=user.profile_fields.get(self.fieldname),
max_length=250,
disabled=self.readonly,
required=False,
)
def get_value_display_data(self, request, user, value):
return {"text": value, "url": value}
| 5,375
|
Python
|
.py
| 136
| 30.426471
| 85
| 0.616583
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,413
|
serializers.py
|
rafalp_Misago/misago/users/profilefields/serializers.py
|
from ..permissions import can_edit_profile_details
def serialize_profilefields_data(request, profilefields, user):
data = {"id": user.pk, "groups": [], "edit": False}
can_edit = can_edit_profile_details(request.user_acl, user)
has_editable_fields = False
for group in profilefields.get_fields_groups():
group_fields = []
for field in group["fields"]:
display_data = field.get_display_data(request, user)
if display_data:
group_fields.append(display_data)
if can_edit and field.is_editable(request, user):
has_editable_fields = True
if group_fields:
data["groups"].append({"name": group["name"], "fields": group_fields})
data["edit"] = can_edit and has_editable_fields
return data
| 814
|
Python
|
.py
| 17
| 39
| 82
| 0.638432
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,414
|
default.py
|
rafalp_Misago/misago/users/profilefields/default.py
|
import re
from django.forms import ValidationError
from django.utils.translation import pgettext, pgettext_lazy
from . import basefields
class BioField(basefields.UrlifiedTextareaProfileField):
fieldname = "bio"
label = pgettext_lazy("bio profile field", "Bio")
class RealNameField(basefields.TextProfileField):
fieldname = "real_name"
label = pgettext_lazy("real_name profile field", "Real name")
class LocationField(basefields.TextProfileField):
fieldname = "location"
label = pgettext_lazy("location profile field", "Location")
class GenderField(basefields.ChoiceProfileField):
fieldname = "gender"
label = pgettext_lazy("gender profile field", "Gender")
choices = (
("", pgettext_lazy("gender profile field choice", "Not specified")),
("secret", pgettext_lazy("gender profile field choice", "Not telling")),
("female", pgettext_lazy("gender profile field choice", "Female")),
("male", pgettext_lazy("gender profile field choice", "Male")),
("enby", pgettext_lazy("gender profile field choice", "Non-binary")),
)
class WebsiteField(basefields.UrlProfileField):
fieldname = "website"
label = pgettext_lazy("website profile field", "Website")
help_text = pgettext_lazy(
"website profile field",
'If you own a website you wish to share on your profile, you may enter its address here. Remember that, for it to be valid, it should start with either "http://" or "https://".',
)
class SkypeIdField(basefields.TextProfileField):
fieldname = "skype"
label = pgettext_lazy("skype id profile field", "Skype ID")
class TwitterHandleField(basefields.TextProfileField):
fieldname = "twitter"
label = pgettext_lazy("twitter handle profile field", "X (formerly Twitter) handle")
def get_help_text(self, user):
return pgettext_lazy(
"twitter handle profile field",
'If you own an X account, here you may enter your X handle for other users to find you. Starting your handle with "@" sign is optional. Either "@%(slug)s" or "%(slug)s" are valid values.',
) % {"slug": user.slug}
def get_value_display_data(self, request, user, value):
return {"text": "@%s" % value, "url": "https://twitter.com/%s" % value}
def clean(self, request, user, data):
data = data.lstrip("@")
if data and not re.search(r"^[A-Za-z0-9_]+$", data):
raise ValidationError(
pgettext(
"twitter handle profile field",
"This is not a valid X handle.",
)
)
return data
class JoinIpField(basefields.TextProfileField):
fieldname = "join_ip"
label = pgettext_lazy("join ip profile field", "Join IP")
readonly = True
def get_value_display_data(self, request, user, value):
if not request.user_acl.get("can_see_users_ips"):
return None
if not user.joined_from_ip:
return None
return {"text": user.joined_from_ip}
| 3,059
|
Python
|
.py
| 63
| 41.253968
| 200
| 0.665096
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,415
|
__init__.py
|
rafalp_Misago/misago/users/profilefields/__init__.py
|
import copy
import logging
from django.core.exceptions import ValidationError
from django.urls import reverse
from django.utils.module_loading import import_string
from django.utils.translation import gettext
from ...conf import settings
from .basefields import *
from .serializers import serialize_profilefields_data
logger = logging.getLogger("misago.users.ProfileFields")
class ProfileFields:
def __init__(self, fields_groups):
self.is_loaded = False
self.fields_groups = fields_groups
self.fields_dict = {}
def load(self):
self.fields_dict = {}
fieldnames = {}
for group in self.fields_groups:
for field_path in group["fields"]:
field = import_string(field_path)
field._field_path = field_path
if field_path in self.fields_dict:
raise ValueError(
"%s profile field has been specified twice" % field._field_path
)
if not getattr(field, "fieldname", None):
raise ValueError(
"%s profile field has to specify fieldname attribute"
% field._field_path
)
if field.fieldname in fieldnames:
raise ValueError(
(
'%s profile field defines fieldname "%s" '
"that is already in use by the %s"
)
% (
field._field_path,
field.fieldname,
fieldnames[field.fieldname],
)
)
fieldnames[field.fieldname] = field_path
self.fields_dict[field_path] = field()
self.is_loaded = True
def get_fields(self):
if not self.is_loaded:
self.load()
return self.fields_dict.values()
def get_fields_groups(self):
if not self.is_loaded:
self.load()
groups = []
for group in self.fields_groups:
group_dict = {"name": gettext(group["name"]), "fields": []}
for field_path in group["fields"]:
field = self.fields_dict[field_path]
group_dict["fields"].append(field)
if group_dict["fields"]:
groups.append(group_dict)
return groups
def add_fields_to_form(self, request, user, form):
if not self.is_loaded:
self.load()
form._profile_fields = []
for field in self.get_fields():
if not field.is_editable(request, user):
continue
form._profile_fields.append(field.fieldname)
form.fields[field.fieldname] = field.get_form_field(request, user)
def add_fields_to_admin_form(self, request, user, form):
self.add_fields_to_form(request, user, form)
form._profile_fields_groups = []
for group in self.fields_groups:
group_dict = {"name": gettext(group["name"]), "fields": []}
for field_path in group["fields"]:
field = self.fields_dict[field_path]
if field.fieldname in form._profile_fields:
group_dict["fields"].append(field.fieldname)
if group_dict["fields"]:
form._profile_fields_groups.append(group_dict)
def clean_form(self, request, user, form, cleaned_data):
for field in self.get_fields():
if field.fieldname not in cleaned_data:
continue
try:
cleaned_data[field.fieldname] = field.clean(
request, user, cleaned_data[field.fieldname]
)
except ValidationError as e:
form.add_error(field.fieldname, e)
return cleaned_data
def update_user_profile_fields(self, request, user, form):
old_fields = copy.copy(user.profile_fields or {})
new_fields = {}
for fieldname in form._profile_fields:
if fieldname in form.cleaned_data:
new_fields[fieldname] = form.cleaned_data[fieldname]
user.profile_fields = new_fields
old_fields_reduced = {k: v for k, v in old_fields.items() if v}
new_fields_reduced = {k: v for k, v in new_fields.items() if v}
if old_fields_reduced != new_fields_reduced:
self.log_profile_fields_update(request, user)
def log_profile_fields_update(self, request, user):
if request.user == user:
log_message = "%s edited own profile fields" % user.username
else:
log_message = "%s edited %s's (#%s) profile fields" % (
request.user,
user.username,
user.pk,
)
logger.info(
log_message,
extra={
"absolute_url": request.build_absolute_uri(
reverse(
"misago:user-details", kwargs={"slug": user.slug, "pk": user.pk}
)
)
},
)
def search_users(self, criteria, queryset):
if not self.is_loaded:
self.load()
q_obj = None
for field in self.fields_dict.values():
q = field.search_users(criteria)
if q:
if q_obj:
q_obj = q_obj | q
else:
q_obj = q
if q_obj:
return queryset.filter(q_obj)
return queryset
profilefields = ProfileFields(settings.MISAGO_PROFILE_FIELDS)
| 5,720
|
Python
|
.py
| 138
| 28.108696
| 88
| 0.539448
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,416
|
uploaded.py
|
rafalp_Misago/misago/users/avatars/uploaded.py
|
from pathlib import Path
from django.core.exceptions import ValidationError
from django.utils.translation import pgettext
from PIL import Image
from . import store
from ...conf import settings
ALLOWED_EXTENSIONS = (".gif", ".png", ".jpg", ".jpeg")
ALLOWED_MIME_TYPES = ("image/gif", "image/jpeg", "image/png", "image/mpo")
def handle_uploaded_file(request, user, uploaded_file):
image = validate_uploaded_file(request.settings, uploaded_file)
store.store_temporary_avatar(user, image)
def validate_uploaded_file(settings, uploaded_file):
try:
validate_file_size(settings, uploaded_file)
validate_extension(uploaded_file)
validate_mime(uploaded_file)
return validate_dimensions(uploaded_file)
except ValidationError as e:
try:
temporary_file_path = Path(uploaded_file.temporary_file_path())
if temporary_file_path.exists():
temporary_file_path.unlink()
except Exception: # pylint: disable=broad-except
pass
raise e
def validate_file_size(settings, uploaded_file):
upload_limit = settings.avatar_upload_limit * 1024
if uploaded_file.size > upload_limit:
raise ValidationError(
pgettext("avatar upload size validator", "Uploaded file is too big.")
)
def validate_extension(uploaded_file):
lowercased_name = uploaded_file.name.lower()
for extension in ALLOWED_EXTENSIONS:
if lowercased_name.endswith(extension):
return True
raise ValidationError(
pgettext(
"avatar upload validator",
"Uploaded file type is not supported.",
)
)
def validate_mime(uploaded_file):
if uploaded_file.content_type not in ALLOWED_MIME_TYPES:
raise ValidationError(
pgettext(
"avatar upload validator",
"Uploaded file type is not supported.",
)
)
def validate_dimensions(uploaded_file):
image = Image.open(uploaded_file)
min_size = max(settings.MISAGO_AVATARS_SIZES)
if min(image.size) < min_size:
message = pgettext(
"avatar upload dimensions validator",
"Uploaded image should be at least %(size)s pixels tall and wide.",
)
raise ValidationError(message % {"size": min_size})
if image.size[0] * image.size[1] > 2000 * 3000:
message = pgettext(
"avatar upload dimensions validator",
"Uploaded image is too big.",
)
raise ValidationError(message)
image_ratio = float(min(image.size)) / float(max(image.size))
if image_ratio < 0.25:
message = pgettext(
"avatar upload dimensions validator",
"Uploaded image ratio cannot be greater than 16:9.",
)
raise ValidationError(message)
return image
def clean_crop(image, crop):
message = pgettext(
"avatar upload crop validator",
"Crop data is invalid. Please try again.",
)
crop_dict = {}
try:
crop_dict = {
"x": float(crop["offset"]["x"]),
"y": float(crop["offset"]["y"]),
"zoom": float(crop["zoom"]),
}
except (KeyError, TypeError, ValueError):
raise ValidationError(message)
if crop_dict["zoom"] < 0 or crop_dict["zoom"] > 1:
raise ValidationError(message)
min_size = max(settings.MISAGO_AVATARS_SIZES)
zoomed_size = (
round(float(image.size[0]) * crop_dict["zoom"], 2),
round(float(image.size[1]) * crop_dict["zoom"], 2),
)
if min(zoomed_size) < min_size:
raise ValidationError(message)
crop_square = {"x": crop_dict["x"] * -1, "y": crop_dict["y"] * -1}
if crop_square["x"] < 0 or crop_square["y"] < 0:
raise ValidationError(message)
if crop_square["x"] + min_size > zoomed_size[0]:
raise ValidationError(message)
if crop_square["y"] + min_size > zoomed_size[1]:
raise ValidationError(message)
return crop_dict
def crop_source_image(user, source, crop):
if source == "tmp":
image = Image.open(user.avatar_tmp)
else:
image = Image.open(user.avatar_src)
crop = clean_crop(image, crop)
min_size = max(settings.MISAGO_AVATARS_SIZES)
if image.size[0] == min_size and image.size[0] == image.size[1]:
cropped_image = image
else:
upscale = 1.0 / crop["zoom"]
cropped_image = image.crop(
(
int(round(crop["x"] * upscale * -1, 0)),
int(round(crop["y"] * upscale * -1, 0)),
int(round((crop["x"] - min_size) * upscale * -1, 0)),
int(round((crop["y"] - min_size) * upscale * -1, 0)),
)
)
if source == "tmp":
store.store_new_avatar(user, cropped_image, delete_tmp=False)
store.store_original_avatar(user)
else:
store.store_new_avatar(user, cropped_image, delete_src=False)
return crop
def has_temporary_avatar(user):
return bool(user.avatar_tmp)
def has_source_avatar(user):
return bool(user.avatar_src)
| 5,127
|
Python
|
.py
| 133
| 30.639098
| 81
| 0.623209
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,417
|
default.py
|
rafalp_Misago/misago/users/avatars/default.py
|
from . import downloaded, dynamic, gallery, gravatar
SET_DEFAULT_AVATAR = {
"gravatar": gravatar.set_avatar,
"dynamic": dynamic.set_avatar,
"gallery": gallery.set_random_avatar,
}
def set_default_avatar(user, default_avatar, gravatar_fallback):
try:
SET_DEFAULT_AVATAR[default_avatar](user)
except RuntimeError:
if gallery.galleries_exist():
SET_DEFAULT_AVATAR[gravatar_fallback](user)
else:
dynamic.set_avatar(user)
def set_default_avatar_from_url(user, avatar_url):
try:
downloaded.set_avatar(user, avatar_url)
except RuntimeError:
dynamic.set_avatar(user)
| 656
|
Python
|
.py
| 19
| 28.421053
| 64
| 0.689873
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,418
|
__init__.py
|
rafalp_Misago/misago/users/avatars/__init__.py
|
from . import store, gravatar, downloaded, dynamic, gallery, uploaded
from .default import set_default_avatar, set_default_avatar_from_url
__all__ = [
"AVATAR_TYPES",
"delete_avatar",
"downloaded",
"dynamic",
"gallery",
"gravatar",
"set_default_avatar",
"set_default_avatar_from_url",
"store",
"uploaded",
]
AVATAR_TYPES = ("gravatar", "dynamic", "gallery", "uploaded")
delete_avatar = store.delete_avatar
| 449
|
Python
|
.py
| 16
| 24.375
| 69
| 0.676744
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,419
|
gravatar.py
|
rafalp_Misago/misago/users/avatars/gravatar.py
|
from io import BytesIO
import requests
from PIL import Image
from . import store
from ...conf import settings
GRAVATAR_URL = "http://www.gravatar.com/avatar/%s?s=%s&d=404"
class GravatarError(RuntimeError):
pass
class NoGravatarAvailable(GravatarError):
pass
def set_avatar(user):
url_formats = (user.email_hash, max(settings.MISAGO_AVATARS_SIZES))
try:
r = requests.get(GRAVATAR_URL % url_formats, timeout=5)
if r.status_code != 200:
raise NoGravatarAvailable("gravatar is not available for this e-mail")
image = Image.open(BytesIO(r.content))
store.store_new_avatar(user, image)
except requests.exceptions.RequestException:
raise GravatarError("failed to connect to gravatar servers")
| 769
|
Python
|
.py
| 20
| 33.35
| 82
| 0.728011
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,420
|
store.py
|
rafalp_Misago/misago/users/avatars/store.py
|
import os
from hashlib import md5
from io import BytesIO
from django.core.files.base import ContentFile
from django.utils.crypto import get_random_string
from PIL.Image import Resampling
from ...conf import settings
def normalize_image(image):
"""strip image of animation, convert to RGBA"""
image.seek(0)
return image.copy().convert("RGBA")
def delete_avatar(user, delete_tmp=True, delete_src=True):
if delete_tmp and user.avatar_tmp:
user.avatar_tmp.delete(save=False)
if delete_src and user.avatar_src:
user.avatar_src.delete(save=False)
for avatar in user.avatar_set.all():
avatar.image.delete(save=False)
user.avatar_set.all().delete()
def store_avatar(user, image):
from ..models import Avatar
image = normalize_image(image)
avatars = []
for size in sorted(settings.MISAGO_AVATARS_SIZES, reverse=True):
image_stream = BytesIO()
image = image.resize((size, size), Resampling.LANCZOS)
image.save(image_stream, "PNG")
avatars.append(
Avatar.objects.create(
user=user,
size=size,
image=ContentFile(image_stream.getvalue(), "avatar"),
)
)
user.avatars = [{"size": a.size, "url": a.url} for a in avatars]
user.save(update_fields=["avatars"])
def store_new_avatar(user, image, delete_tmp=True, delete_src=True):
delete_avatar(user, delete_tmp=delete_tmp, delete_src=delete_src)
store_avatar(user, image)
def store_temporary_avatar(user, image):
image_stream = BytesIO()
normalize_image(image)
image.save(image_stream, "PNG")
if user.avatar_tmp:
user.avatar_tmp.delete(save=False)
user.avatar_tmp = ContentFile(image_stream.getvalue(), "avatar")
user.save(update_fields=["avatar_tmp"])
def store_original_avatar(user):
if user.avatar_src:
user.avatar_src.delete(save=False)
user.avatar_src = user.avatar_tmp
user.avatar_tmp = None
user.save(update_fields=["avatar_tmp", "avatar_src"])
def upload_to(instance, filename):
spread_path = md5(get_random_string(64).encode()).hexdigest()
secret = get_random_string(32)
filename_clean = "%s.png" % get_random_string(32)
return os.path.join(
"avatars", spread_path[:2], spread_path[2:4], secret, filename_clean
)
| 2,360
|
Python
|
.py
| 60
| 33.216667
| 76
| 0.681038
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,421
|
dynamic.py
|
rafalp_Misago/misago/users/avatars/dynamic.py
|
import os
from django.utils.module_loading import import_string
from PIL import Image, ImageColor, ImageDraw, ImageFont
from . import store
from ...conf import settings
COLOR_WHEEL = (
"#d32f2f",
"#c2185b",
"#7b1fa2",
"#512da8",
"#303f9f",
"#1976d2",
"#0288D1",
"#0288d1",
"#0097a7",
"#00796b",
"#388e3c",
"#689f38",
"#afb42b",
"#fbc02d",
"#ffa000",
"#f57c00",
"#e64a19",
)
COLOR_WHEEL_LEN = len(COLOR_WHEEL)
FONT_FILE = os.path.join(os.path.dirname(__file__), "font.ttf")
def set_avatar(user):
drawer_function = import_string(settings.MISAGO_DYNAMIC_AVATAR_DRAWER)
image = drawer_function(user)
store.store_new_avatar(user, image)
def draw_default(user):
"""default avatar drawer that draws username's first letter on color"""
image_size = max(settings.MISAGO_AVATARS_SIZES)
image = Image.new("RGBA", (image_size, image_size), 0)
image = draw_avatar_bg(user, image)
image = draw_avatar_flavour(user, image)
return image
def draw_avatar_bg(user, image):
image_size = image.size
color_index = user.pk - COLOR_WHEEL_LEN * (user.pk // COLOR_WHEEL_LEN)
main_color = COLOR_WHEEL[color_index]
rgb = ImageColor.getrgb(main_color)
bg_drawer = ImageDraw.Draw(image)
bg_drawer.rectangle([(0, 0), image_size], rgb)
return image
def draw_avatar_flavour(user, image):
string = user.username[0]
image_size = image.size[0]
size = int(image_size * 0.7)
font = ImageFont.truetype(FONT_FILE, size=size)
text_box = font.getbbox(string)
text_pos = ((image_size - text_box[2]) / 2, (image_size - text_box[3]) / 2)
writer = ImageDraw.Draw(image)
writer.text(text_pos, string, font=font)
return image
| 1,769
|
Python
|
.py
| 55
| 27.690909
| 79
| 0.667061
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,422
|
downloaded.py
|
rafalp_Misago/misago/users/avatars/downloaded.py
|
from io import BytesIO
import requests
from PIL import Image
from . import store
class AvatarDownloadError(RuntimeError):
pass
def set_avatar(user, avatar_url):
try:
r = requests.get(avatar_url, timeout=5)
if r.status_code != 200:
raise AvatarDownloadError("could not retrieve avatar from the server")
image = Image.open(BytesIO(r.content))
# Crop avatar into square
width, height = image.size
if width > height:
left = int((width - height) / 2)
image = image.crop((left, 0, width + left, height))
elif height > width:
top = int((height - width) / 2)
image = image.crop((0, top, width, top + height))
store.store_new_avatar(user, image)
except requests.exceptions.RequestException:
raise AvatarDownloadError("failed to connect to avatar server")
| 900
|
Python
|
.py
| 23
| 31.434783
| 82
| 0.644752
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,423
|
gallery.py
|
rafalp_Misago/misago/users/avatars/gallery.py
|
import random
from pathlib import Path
from django.core.files.base import ContentFile
from PIL import Image
from . import store
from ...conf import settings
DEFAULT_GALLERY = "__default__"
def get_available_galleries(include_default=False):
"""
Returns list of dicts containing 'name' and list of images
Only jpgs, gifs and pngs are supported avatar images.
Galleries are
"""
from ..models import AvatarGallery
galleries = []
galleries_dicts = {}
for image in AvatarGallery.objects.all():
if image.gallery == DEFAULT_GALLERY and not include_default:
continue
if image.gallery not in galleries_dicts:
galleries_dicts[image.gallery] = {"name": image.gallery, "images": []}
galleries.append(galleries_dicts[image.gallery])
galleries_dicts[image.gallery]["images"].append(image)
return galleries
def galleries_exist():
from ..models import AvatarGallery
return AvatarGallery.objects.exists()
def load_avatar_galleries():
from ..models import AvatarGallery
galleries = []
for directory in Path(settings.MISAGO_AVATAR_GALLERY).iterdir():
if not directory.is_dir():
continue
name = directory.name
images = glob_gallery_images(directory)
for image in images:
with open(image, "rb") as image_file:
galleries.append(
AvatarGallery.objects.create(
gallery=name, image=ContentFile(image_file.read(), "image")
)
)
return galleries
def glob_gallery_images(directory):
images = []
images.extend(directory.glob("*.gif"))
images.extend(directory.glob("*.jpg"))
images.extend(directory.glob("*.jpeg"))
images.extend(directory.glob("*.png"))
return images
def set_avatar(user, avatar):
store.store_new_avatar(user, Image.open(avatar.image))
def set_random_avatar(user):
galleries = get_available_galleries(include_default=True)
if not galleries:
raise RuntimeError("no avatar galleries are set")
avatars_list = []
for gallery in galleries:
if gallery["name"] == DEFAULT_GALLERY:
avatars_list = gallery["images"]
break
else:
avatars_list += gallery["images"]
random_avatar = random.choice(avatars_list)
store.store_new_avatar(user, Image.open(random_avatar.image))
| 2,461
|
Python
|
.py
| 65
| 30.461538
| 83
| 0.664274
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,424
|
api.py
|
rafalp_Misago/misago/users/urls/api.py
|
from django.urls import path
from ...core.apirouter import MisagoApiRouter
from ..api import auth, captcha, mention
from ..api.ranks import RanksViewSet
from ..api.usernamechanges import UsernameChangesViewSet
from ..api.users import UserViewSet
urlpatterns = [
path("auth/", auth.gateway, name="auth"),
path("auth/criteria/", auth.get_criteria, name="auth-criteria"),
path("auth/send-activation/", auth.send_activation, name="send-activation"),
path(
"auth/send-password-form/",
auth.send_password_form,
name="send-password-form",
),
path(
"auth/change-password/<int:pk>/<slug:token>/",
auth.change_forgotten_password,
name="change-forgotten-password",
),
path("captcha-question/", captcha.question, name="captcha-question"),
path("mention/", mention.mention_suggestions, name="mention-suggestions"),
]
router = MisagoApiRouter()
router.register(r"ranks", RanksViewSet)
router.register(r"users", UserViewSet)
router.register(r"username-changes", UsernameChangesViewSet, basename="usernamechange")
urlpatterns += router.urls
| 1,112
|
Python
|
.py
| 28
| 35.607143
| 87
| 0.72988
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,425
|
__init__.py
|
rafalp_Misago/misago/users/urls/__init__.py
|
from django.urls import include, path
from ...core.views import home_redirect
from ..views import (
activation,
auth,
avatarserver,
forgottenpassword,
lists,
profile,
)
urlpatterns = [
path("banned/", home_redirect, name="banned"),
path("logout/", auth.logout, name="logout"),
path(
"request-activation/",
activation.request_activation,
name="request-activation",
),
path(
"activation/<int:pk>/<slug:token>/",
activation.activate_by_token,
name="activate-by-token",
),
path(
"forgotten-password/",
forgottenpassword.request_reset,
name="forgotten-password",
),
path(
"forgotten-password/<int:pk>/<slug:token>/",
forgottenpassword.reset_password_form,
name="forgotten-password-change-form",
),
]
urlpatterns += [
path(
"users/",
include(
[
path("", lists.landing, name="users"),
path(
"active-posters/",
lists.ActivePostersView.as_view(),
name="users-active-posters",
),
path(
"<slug:slug>/",
lists.RankUsersView.as_view(),
name="users-rank",
),
path(
"<slug:slug>/<int:page>/",
lists.RankUsersView.as_view(),
name="users-rank",
),
]
),
)
]
urlpatterns += [
path(
"u/<slug:slug>/<int:pk>/",
include(
[
path("", profile.LandingView.as_view(), name="user"),
path("posts/", profile.UserPostsView.as_view(), name="user-posts"),
path(
"threads/",
profile.UserThreadsView.as_view(),
name="user-threads",
),
path(
"followers/",
profile.UserFollowersView.as_view(),
name="user-followers",
),
path(
"follows/",
profile.UserFollowsView.as_view(),
name="user-follows",
),
path(
"details/",
profile.UserProfileDetailsView.as_view(),
name="user-details",
),
path(
"username-history/",
profile.UserUsernameHistoryView.as_view(),
name="username-history",
),
path("ban-details/", profile.UserBanView.as_view(), name="user-ban"),
]
),
)
]
urlpatterns += [
path("avatar/", avatarserver.blank_avatar, name="blank-avatar"),
path(
"avatar/<int:pk>/<int:size>/",
avatarserver.user_avatar,
name="user-avatar",
),
]
| 3,005
|
Python
|
.py
| 104
| 17.182692
| 85
| 0.459413
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,426
|
users.py
|
rafalp_Misago/misago/users/api/users.py
|
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.db import transaction
from django.db.models import F
from django.http import Http404
from django.shortcuts import get_object_or_404
from django.utils.translation import pgettext
from rest_framework import status, viewsets
from rest_framework.decorators import action
from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
from rest_framework.response import Response
from ...acl.objectacl import add_acl_to_obj
from ...categories.models import Category
from ...core.rest_permissions import IsAuthenticatedOrReadOnly
from ...core.shortcuts import get_int_or_404
from ...threads.moderation import hide_post, hide_thread
from ..bans import get_user_ban
from ..datadownloads import request_user_data_download, user_has_data_download_request
from ..deletesrecord import record_user_deleted_by_staff
from ..online.utils import get_user_status
from ..permissions import (
allow_browse_users_list,
allow_delete_user,
allow_edit_profile_details,
allow_follow_user,
allow_moderate_avatar,
allow_rename_user,
allow_see_ban_details,
)
from ..profilefields import profilefields, serialize_profilefields_data
from ..serializers import BanDetailsSerializer, UserSerializer
from ..viewmodels import Followers, Follows, UserPosts, UserThreads
from .rest_permissions import BasePermission, UnbannedAnonOnly
from .userendpoints.avatar import avatar_endpoint, moderate_avatar_endpoint
from .userendpoints.create import create_endpoint
from .userendpoints.editdetails import edit_details_endpoint
from .userendpoints.list import list_endpoint
from .userendpoints.username import moderate_username_endpoint, username_endpoint
User = get_user_model()
class UserViewSetPermission(BasePermission):
def has_permission(self, request, view):
if view.action == "create":
policy = UnbannedAnonOnly()
else:
policy = IsAuthenticatedOrReadOnly()
return policy.has_permission(request, view)
def allow_self_only(user, pk, message):
if user.is_anonymous:
raise PermissionDenied(
pgettext("users api", "You have to sign in to perform this action.")
)
if user.pk != int(pk):
raise PermissionDenied(message)
class UserViewSet(viewsets.GenericViewSet):
permission_classes = (UserViewSetPermission,)
parser_classes = (FormParser, JSONParser, MultiPartParser)
queryset = User.objects
def get_queryset(self):
relations = ("rank", "online_tracker", "ban_cache")
return self.queryset.select_related(*relations)
def get_user(self, request, pk):
user = get_object_or_404(self.get_queryset(), pk=get_int_or_404(pk))
if not user.is_active and not request.user.is_misago_admin:
raise Http404()
return user
def list(self, request):
allow_browse_users_list(request.user_acl)
return list_endpoint(request)
def create(self, request):
if request.settings.enable_oauth2_client:
raise PermissionDenied(
pgettext(
"users api",
"This feature has been disabled. Please use %(provider)s to sign in.",
)
% {"provider": request.settings.oauth2_provider}
)
return create_endpoint(request)
def retrieve(self, request, pk=None):
profile = self.get_user(request, pk)
add_acl_to_obj(request.user_acl, profile)
profile.status = get_user_status(request, profile)
serializer = UserProfileSerializer(profile, context={"request": request})
profile_json = serializer.data
if not profile.is_active:
profile_json["is_active"] = False
if profile.is_deleting_account:
profile_json["is_deleting_account"] = True
return Response(profile_json)
@action(methods=["get", "post"], detail=True)
def avatar(self, request, pk=None):
get_int_or_404(pk)
allow_self_only(
request.user,
pk,
pgettext("users api", "You can't change other users avatars."),
)
return avatar_endpoint(request)
@action(methods=["get"], detail=True)
def details(self, request, pk=None):
profile = self.get_user(request, pk)
data = serialize_profilefields_data(request, profilefields, profile)
return Response(data)
@action(
methods=["get", "post"],
detail=True,
url_path="edit-details",
url_name="edit-details",
)
def edit_details(self, request, pk=None):
profile = self.get_user(request, pk)
allow_edit_profile_details(request.user_acl, profile)
return edit_details_endpoint(request, profile)
@action(methods=["post"], detail=True)
def follow(self, request, pk=None):
profile = self.get_user(request, pk)
allow_follow_user(request.user_acl, profile)
profile_followers = profile.followers
with transaction.atomic():
if request.user.is_following(profile):
request.user.follows.remove(profile)
followed = False
profile_followers -= 1
profile.followers = F("followers") - 1
request.user.following = F("following") - 1
else:
request.user.follows.add(profile)
followed = True
profile_followers += 1
profile.followers = F("followers") + 1
request.user.following = F("following") + 1
profile.save(update_fields=["followers"])
request.user.save(update_fields=["following"])
return Response({"is_followed": followed, "followers": profile_followers})
@action(detail=True)
def ban(self, request, pk=None):
profile = self.get_user(request, pk)
allow_see_ban_details(request.user_acl, profile)
ban = get_user_ban(profile, request.cache_versions)
if ban:
return Response(BanDetailsSerializer(ban).data)
return Response({})
@action(
methods=["get", "post"],
detail=True,
url_path="moderate-avatar",
url_name="moderate-avatar",
)
def moderate_avatar(self, request, pk=None):
profile = self.get_user(request, pk)
allow_moderate_avatar(request.user_acl, profile)
return moderate_avatar_endpoint(request, profile)
@action(
methods=["get", "post"],
detail=True,
url_path="moderate-username",
url_name="moderate-username",
)
def moderate_username(self, request, pk=None):
profile = self.get_user(request, pk)
allow_rename_user(request.user_acl, profile)
return moderate_username_endpoint(request, profile)
@action(methods=["get", "post"], detail=True)
def delete(self, request, pk=None):
profile = self.get_user(request, pk)
allow_delete_user(request.user_acl, profile)
if request.method == "POST":
with transaction.atomic():
profile.lock()
if request.data.get("with_content"):
profile.delete_content()
else:
categories_to_sync = set()
threads = profile.thread_set.select_related(
"category", "first_post"
).filter(is_hidden=False)
for thread in threads.iterator(chunk_size=50):
categories_to_sync.add(thread.category_id)
hide_thread(request, thread)
posts = profile.post_set.select_related(
"category", "thread", "thread__category"
).filter(is_hidden=False)
for post in posts.iterator(chunk_size=50):
categories_to_sync.add(post.category_id)
hide_post(request.user, post)
post.thread.synchronize()
post.thread.save()
categories = Category.objects.filter(id__in=categories_to_sync)
for category in categories.iterator():
category.synchronize()
category.save()
profile.delete(anonymous_username=request.settings.anonymous_username)
record_user_deleted_by_staff()
return Response({})
@action(methods=["get"], detail=True)
def followers(self, request, pk=None):
profile = self.get_user(request, pk)
page = get_int_or_404(request.query_params.get("page", 0))
if page == 1:
page = 0 # api allows explicit first page
search = request.query_params.get("search")
users = Followers(request, profile, page, search)
return Response(users.get_frontend_context())
@action(methods=["get"], detail=True)
def follows(self, request, pk=None):
profile = self.get_user(request, pk)
page = get_int_or_404(request.query_params.get("page", 0))
if page == 1:
page = 0 # api allows explicit first page
search = request.query_params.get("search")
users = Follows(request, profile, page, search)
return Response(users.get_frontend_context())
@action(methods=["get"], detail=True)
def threads(self, request, pk=None):
profile = self.get_user(request, pk)
start = get_int_or_404(request.query_params.get("start", 0))
feed = UserThreads(request, profile, start)
return Response(feed.get_frontend_context())
@action(methods=["get"], detail=True)
def posts(self, request, pk=None):
profile = self.get_user(request, pk)
start = get_int_or_404(request.query_params.get("start", 0))
feed = UserPosts(request, profile, start)
return Response(feed.get_frontend_context())
UserProfileSerializer = UserSerializer.subset_fields(
"id",
"username",
"slug",
"email",
"joined_on",
"rank",
"title",
"avatars",
"is_avatar_locked",
"signature",
"is_signature_locked",
"followers",
"following",
"threads",
"posts",
"acl",
"is_followed",
"is_blocked",
"real_name",
"status",
"api",
"url",
)
| 10,445
|
Python
|
.py
| 248
| 33.032258
| 90
| 0.638462
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,427
|
rest_permissions.py
|
rafalp_Misago/misago/users/api/rest_permissions.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext
from rest_framework.permissions import BasePermission
from ...core.exceptions import Banned
from ..bans import get_request_ip_ban
from ..models import Ban
class UnbannedOnly(BasePermission):
def is_request_banned(self, request):
ban = get_request_ip_ban(request)
if ban:
hydrated_ban = Ban(
check_type=Ban.IP,
user_message=ban["message"],
expires_on=ban["expires_on"],
)
raise Banned(hydrated_ban)
def has_permission(self, request, view):
self.is_request_banned(request)
return True
class UnbannedAnonOnly(UnbannedOnly):
def has_permission(self, request, view):
if request.user.is_authenticated:
raise PermissionDenied(
pgettext(
"anonymous api",
"This action is not available to signed in users.",
)
)
self.is_request_banned(request)
return True
| 1,100
|
Python
|
.py
| 30
| 27.166667
| 71
| 0.629351
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,428
|
usernamechanges.py
|
rafalp_Misago/misago/users/api/usernamechanges.py
|
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied
from django.db.models import Q
from django.shortcuts import get_object_or_404
from django.utils.translation import pgettext
from rest_framework import viewsets
from rest_framework.response import Response
from ...core.shortcuts import get_int_or_404, paginate, pagination_dict
from ..models import UsernameChange
from ..serializers import UsernameChangeSerializer
from .rest_permissions import BasePermission
User = get_user_model()
class UsernameChangesViewSetPermission(BasePermission):
def has_permission(self, request, view):
try:
user_pk = int(request.query_params.get("user"))
except (ValueError, TypeError):
user_pk = -1
if user_pk == request.user.pk:
return True
if not request.user_acl.get("can_see_users_name_history"):
raise PermissionDenied(
pgettext(
"username history api",
"You don't have permission to see other users name history.",
)
)
return True
class UsernameChangesViewSet(viewsets.GenericViewSet):
permission_classes = (UsernameChangesViewSetPermission,)
serializer_class = UsernameChangeSerializer
def get_queryset(self):
queryset = UsernameChange.objects
if self.request.query_params.get("user"):
user_pk = get_int_or_404(self.request.query_params.get("user"))
queryset = get_object_or_404(User.objects, pk=user_pk).namechanges
if self.request.query_params.get("search"):
search_phrase = self.request.query_params.get("search").strip()
if search_phrase:
queryset = queryset.filter(
Q(changed_by_username__istartswith=search_phrase)
| Q(new_username__istartswith=search_phrase)
| Q(old_username__istartswith=search_phrase)
)
return queryset.select_related("user", "changed_by").order_by("-id")
def list(self, request):
page = get_int_or_404(request.query_params.get("page", 0))
if page == 1:
page = 0 # api allows explicit first page
queryset = self.get_queryset()
list_page = paginate(queryset, page, 12, 4)
data = pagination_dict(list_page)
data.update(
{"results": UsernameChangeSerializer(list_page.object_list, many=True).data}
)
return Response(data)
| 2,549
|
Python
|
.py
| 56
| 36.160714
| 88
| 0.658458
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,429
|
auth.py
|
rafalp_Misago/misago/users/api/auth.py
|
from functools import wraps
from django.contrib import auth
from django.contrib.auth.password_validation import validate_password
from django.core.exceptions import PermissionDenied, ValidationError
from django.utils.translation import pgettext
from django.views.decorators.csrf import csrf_protect
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.response import Response
from ...conf import settings
from ...core.decorators import require_dict_data
from ...core.mail import mail_user
from ..bans import get_user_ban
from ..forms.auth import AuthenticationForm, ResendActivationForm, ResetPasswordForm
from ..serializers import AnonymousUserSerializer, AuthenticatedUserSerializer
from ..tokens import (
is_password_change_token_valid,
make_activation_token,
make_password_change_token,
)
from .rest_permissions import UnbannedAnonOnly, UnbannedOnly
User = auth.get_user_model()
def gateway(request):
if request.method == "POST":
return login(request)
return session_user(request)
def check_delegated_auth(f):
@wraps(f)
def view_disabled_if_auth_is_delegated(request, *args, **kwargs):
if request.settings.enable_oauth2_client:
raise PermissionDenied(
pgettext(
"auth api",
"This feature has been disabled. Please use %(provider)s to sign in.",
)
% {"provider": request.settings.oauth2_provider}
)
return f(request, *args, **kwargs)
return view_disabled_if_auth_is_delegated
@api_view(["POST"])
@permission_classes((UnbannedAnonOnly,))
@check_delegated_auth
@csrf_protect
@require_dict_data
def login(request):
"""
POST /auth/ with CSRF, username and password
will attempt to authenticate new user
"""
form = AuthenticationForm(request.data, request=request)
if form.is_valid():
auth.login(request, form.user_cache)
return Response(AuthenticatedUserSerializer(form.user_cache).data)
return Response(form.get_errors_dict(), status=status.HTTP_400_BAD_REQUEST)
@api_view()
def session_user(request):
"""GET /auth/ will return current auth user, either User or AnonymousUser"""
if request.user.is_authenticated:
serializer = AuthenticatedUserSerializer
else:
serializer = AnonymousUserSerializer
serialized_user = serializer(request.user, context={"acl": request.user_acl}).data
return Response(serialized_user)
@api_view(["GET"])
def get_criteria(request):
"""GET /auth/criteria/ will return password and username criteria for accounts"""
criteria = {
"username": {
"min_length": request.settings.username_length_min,
"max_length": request.settings.username_length_max,
},
"password": [],
}
for validator in settings.AUTH_PASSWORD_VALIDATORS:
validator_dict = {"name": validator["NAME"].split(".")[-1]}
validator_dict.update(validator.get("OPTIONS", {}))
criteria["password"].append(validator_dict)
return Response(criteria)
@api_view(["POST"])
@permission_classes((UnbannedAnonOnly,))
@check_delegated_auth
@csrf_protect
@require_dict_data
def send_activation(request):
"""
POST /auth/send-activation/ with CSRF token and email
will mail account activation link to requester
"""
form = ResendActivationForm(request.data)
if not form.is_valid():
return Response(form.get_errors_dict(), status=status.HTTP_400_BAD_REQUEST)
requesting_user = form.user_cache
mail_subject = pgettext(
"account activation email subject",
"Activate %(user)s account on %(forum_name)s forums",
) % {
"user": requesting_user.username,
"forum_name": request.settings.forum_name,
}
mail_user(
requesting_user,
mail_subject,
"misago/emails/activation/by_user",
context={
"activation_token": make_activation_token(requesting_user),
"settings": request.settings,
},
)
return Response(
{"username": form.user_cache.username, "email": form.user_cache.email}
)
@api_view(["POST"])
@permission_classes((UnbannedOnly,))
@check_delegated_auth
@csrf_protect
@require_dict_data
def send_password_form(request):
"""
POST /auth/send-password-form/ with CSRF token and email
will mail change password form link to requester
"""
form = ResetPasswordForm(request.data)
if not form.is_valid():
return Response(form.get_errors_dict(), status=status.HTTP_400_BAD_REQUEST)
requesting_user = form.user_cache
mail_subject = pgettext(
"change forgotten password email subject",
"Change %(user)s password on %(forum_name)s forums",
) % {
"user": requesting_user.username,
"forum_name": request.settings.forum_name,
}
confirmation_token = make_password_change_token(requesting_user)
mail_user(
requesting_user,
mail_subject,
"misago/emails/change_password_form_link",
context={
"confirmation_token": confirmation_token,
"settings": request.settings,
},
)
return Response(
{"username": form.user_cache.username, "email": form.user_cache.email}
)
class PasswordChangeFailed(Exception):
pass
@api_view(["POST"])
@permission_classes((UnbannedOnly,))
@check_delegated_auth
@csrf_protect
@require_dict_data
def change_forgotten_password(request, pk, token):
"""
POST /auth/change-password/user/token/ with CSRF and new password
will change forgotten password
"""
invalid_message = pgettext(
"change forgotten password api",
"Form link is invalid. Please request new one.",
)
expired_message = pgettext(
"change forgotten password api",
"Your link has expired. Please request new one.",
)
try:
try:
user = User.objects.get(pk=pk, is_active=True)
except User.DoesNotExist:
raise PasswordChangeFailed(invalid_message)
if request.user.is_authenticated and request.user.id != user.id:
raise PasswordChangeFailed(invalid_message)
if not is_password_change_token_valid(user, token):
raise PasswordChangeFailed(invalid_message)
if user.requires_activation:
raise PasswordChangeFailed(expired_message)
if get_user_ban(user, request.cache_versions):
raise PasswordChangeFailed(expired_message)
except PasswordChangeFailed as e:
return Response({"detail": e.args[0]}, status=status.HTTP_400_BAD_REQUEST)
try:
new_password = request.data.get("password", "")
validate_password(new_password, user=user)
user.set_password(new_password)
user.save()
except ValidationError as e:
return Response({"detail": e.messages[0]}, status=status.HTTP_400_BAD_REQUEST)
return Response({"username": user.username})
| 7,076
|
Python
|
.py
| 188
| 31.446809
| 90
| 0.692173
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,430
|
captcha.py
|
rafalp_Misago/misago/users/api/captcha.py
|
from django.http import Http404
from rest_framework.decorators import api_view
from rest_framework.response import Response
@api_view()
def question(request):
if not request.settings.qa_question:
raise Http404()
return Response(
{
"question": request.settings.qa_question,
"help_text": request.settings.qa_help_text,
}
)
| 384
|
Python
|
.py
| 13
| 23.692308
| 55
| 0.6875
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,431
|
ranks.py
|
rafalp_Misago/misago/users/api/ranks.py
|
from rest_framework import mixins, viewsets
from ..models import Rank
from ..serializers import RankSerializer
class RanksViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
serializer_class = RankSerializer
queryset = Rank.objects.filter(is_tab=True).order_by("order")
| 286
|
Python
|
.py
| 6
| 44.833333
| 67
| 0.815884
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,432
|
mention.py
|
rafalp_Misago/misago/users/api/mention.py
|
from django.contrib.auth import get_user_model
from django.template.context_processors import static
from rest_framework.decorators import api_view
from rest_framework.response import Response
from ...conf import settings
User = get_user_model()
@api_view()
def mention_suggestions(request):
suggestions = []
query = request.query_params.get("q", "").lower().strip()[:100]
if query:
queryset = User.objects.filter(slug__startswith=query, is_active=True).order_by(
"slug"
)[:10]
for user in queryset:
try:
avatar = user.avatars[-1]["url"]
except IndexError:
avatar = request.settings.blank_avatar
if not avatar:
avatar = static(settings.MISAGO_BLANK_AVATAR)
suggestions.append({"username": user.username, "avatar": avatar})
return Response(suggestions)
| 916
|
Python
|
.py
| 23
| 31.695652
| 88
| 0.650847
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,433
|
avatar.py
|
rafalp_Misago/misago/users/api/userendpoints/avatar.py
|
import json
from django.core.exceptions import ValidationError
from django.utils.translation import pgettext
from rest_framework import status
from rest_framework.response import Response
from ... import avatars
from ....conf import settings
from ....core.decorators import require_dict_data
from ....core.utils import format_plaintext_for_html
from ...models import AvatarGallery
from ...serializers import ModerateAvatarSerializer
@require_dict_data
def avatar_endpoint(request, pk=None):
if request.user.is_avatar_locked:
if request.user.avatar_lock_user_message:
reason = format_plaintext_for_html(request.user.avatar_lock_user_message)
else:
reason = None
return Response(
{
"detail": pgettext(
"avatar api", "Your avatar is locked. You can't change it."
),
"reason": reason,
},
status=status.HTTP_403_FORBIDDEN,
)
avatar_options = get_avatar_options(request, request.user)
if request.method == "POST":
return avatar_post(request, avatar_options)
return Response(avatar_options)
def get_avatar_options(request, user):
options = {
"avatars": user.avatars,
"generated": True,
"gravatar": False,
"crop_src": False,
"crop_tmp": False,
"upload": False,
"galleries": False,
}
# Allow existing galleries
if avatars.gallery.galleries_exist():
options["galleries"] = []
for gallery in avatars.gallery.get_available_galleries():
gallery_images = []
for image in gallery["images"]:
gallery_images.append({"id": image.id, "url": image.url})
options["galleries"].append(
{"name": gallery["name"], "images": gallery_images}
)
# Can't have custom avatar?
if not request.settings.allow_custom_avatars:
return options
# Allow Gravatar download
options["gravatar"] = True
# Allow crop if we have uploaded temporary avatar
if avatars.uploaded.has_source_avatar(user):
try:
options["crop_src"] = {
"url": user.avatar_src.url,
"crop": json.loads(user.avatar_crop),
"size": max(settings.MISAGO_AVATARS_SIZES),
}
except (TypeError, ValueError):
pass
# Allow crop of uploaded avatar
if avatars.uploaded.has_temporary_avatar(user):
options["crop_tmp"] = {
"url": user.avatar_tmp.url,
"size": max(settings.MISAGO_AVATARS_SIZES),
}
# Allow upload conditions
options["upload"] = {
"limit": request.settings.avatar_upload_limit * 1024,
"allowed_extensions": avatars.uploaded.ALLOWED_EXTENSIONS,
"allowed_mime_types": avatars.uploaded.ALLOWED_MIME_TYPES,
}
return options
class AvatarError(Exception):
pass
def avatar_post(request, options):
user = request.user
data = request.data
avatar_type = data.get("avatar", "nope")
try:
type_options = options[avatar_type]
if not type_options:
return Response(
{
"detail": pgettext(
"avatar api", "This avatar type is not available."
)
},
status=status.HTTP_400_BAD_REQUEST,
)
avatar_strategy = AVATAR_TYPES[avatar_type]
except KeyError:
return Response(
{"detail": pgettext("avatar api", "Unknown avatar type.")},
status=status.HTTP_400_BAD_REQUEST,
)
try:
if avatar_type == "upload":
# avatar_upload strategy requires access to request.settings
response_dict = {"detail": avatar_upload(request, user, data)}
else:
response_dict = {"detail": avatar_strategy(user, data)}
except AvatarError as e:
return Response({"detail": e.args[0]}, status=status.HTTP_400_BAD_REQUEST)
user.save()
updated_options = get_avatar_options(request, user)
response_dict.update(updated_options)
return Response(response_dict)
def avatar_generate(user, data):
avatars.dynamic.set_avatar(user)
return pgettext("avatar api", "New avatar based on your account was set.")
def avatar_gravatar(user, data):
try:
avatars.gravatar.set_avatar(user)
return pgettext("avatar api", "Gravatar was downloaded and set as new avatar.")
except avatars.gravatar.NoGravatarAvailable:
raise AvatarError(
pgettext(
"avatar api", "No Gravatar is associated with your e-mail address."
)
)
except avatars.gravatar.GravatarError:
raise AvatarError(pgettext("avatar api", "Failed to connect to Gravatar."))
def avatar_gallery(user, data):
try:
image_pk = int(data.get("image"))
image = AvatarGallery.objects.get(pk=image_pk)
if image.gallery == "__default__":
raise ValueError()
avatars.gallery.set_avatar(user, image)
return pgettext("avatar api", "Avatar from gallery was set.")
except (TypeError, ValueError, AvatarGallery.DoesNotExist):
raise AvatarError(pgettext("avatar api", "Incorrect image."))
def avatar_upload(request, user, data):
new_avatar = data.get("image")
if not new_avatar:
raise AvatarError(pgettext("avatar api", "No file was sent."))
try:
avatars.uploaded.handle_uploaded_file(request, user, new_avatar)
except ValidationError as e:
raise AvatarError(e.args[0])
# send back url for temp image
return user.avatar_tmp.url
def avatar_crop_src(user, data):
avatar_crop(user, data, "src")
return pgettext("avatar api", "Avatar was re-cropped.")
def avatar_crop_tmp(user, data):
avatar_crop(user, data, "tmp")
return pgettext("avatar api", "Uploaded avatar was set.")
def avatar_crop(user, data, suffix):
try:
crop = avatars.uploaded.crop_source_image(user, suffix, data.get("crop", {}))
user.avatar_crop = json.dumps(crop)
except ValidationError as e:
raise AvatarError(e.args[0])
AVATAR_TYPES = {
"generated": avatar_generate,
"gravatar": avatar_gravatar,
"galleries": avatar_gallery,
"upload": avatar_upload,
"crop_src": avatar_crop_src,
"crop_tmp": avatar_crop_tmp,
}
def moderate_avatar_endpoint(request, profile):
if request.method == "POST":
is_avatar_locked = profile.is_avatar_locked
serializer = ModerateAvatarSerializer(profile, data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
if serializer.validated_data["is_avatar_locked"] and not is_avatar_locked:
avatars.dynamic.set_avatar(profile)
serializer.save()
return Response(
{
"avatars": profile.avatars,
"is_avatar_locked": int(profile.is_avatar_locked),
"avatar_lock_user_message": profile.avatar_lock_user_message,
"avatar_lock_staff_message": profile.avatar_lock_staff_message,
}
)
return Response(
{
"is_avatar_locked": int(profile.is_avatar_locked),
"avatar_lock_user_message": profile.avatar_lock_user_message,
"avatar_lock_staff_message": profile.avatar_lock_staff_message,
}
)
| 7,549
|
Python
|
.py
| 193
| 30.611399
| 87
| 0.632047
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,434
|
editdetails.py
|
rafalp_Misago/misago/users/api/userendpoints/editdetails.py
|
from django import forms
from rest_framework.response import Response
from ...profilefields import profilefields, serialize_profilefields_data
def edit_details_endpoint(request, user):
if request.method == "GET":
return get_form_description(request, user)
return submit_form(request, user)
def get_form_description(request, user):
groups = []
for group in profilefields.get_fields_groups():
group_fields = []
for field in group["fields"]:
if field.is_editable(request, user):
group_fields.append(field.get_form_field_json(request, user))
if group_fields:
groups.append({"name": group["name"], "fields": group_fields})
return Response(groups)
def submit_form(request, user):
fields = []
for field in profilefields.get_fields():
if field.is_editable(request, user):
fields.append(field)
form = DetailsForm(request.data, request=request, user=user)
if form.is_valid():
profilefields.update_user_profile_fields(request, user, form)
user.save(update_fields=["profile_fields"])
return Response(serialize_profilefields_data(request, profilefields, user))
return Response(form.errors, status=400)
class DetailsForm(forms.Form):
def __init__(self, *args, **kwargs):
self.request = kwargs.pop("request")
self.user = kwargs.pop("user")
super().__init__(*args, **kwargs)
profilefields.add_fields_to_form(self.request, self.user, self)
def clean(self):
data = super().clean()
return profilefields.clean_form(self.request, self.user, self, data)
| 1,662
|
Python
|
.py
| 37
| 37.702703
| 83
| 0.67766
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,435
|
create.py
|
rafalp_Misago/misago/users/api/userendpoints/create.py
|
from django.contrib.auth import authenticate, get_user_model, login
from django.core.exceptions import PermissionDenied, ValidationError
from django.db import IntegrityError
from django.utils.translation import pgettext
from django.views.decorators.csrf import csrf_protect
from rest_framework import status
from rest_framework.response import Response
from ... import captcha
from ....legal.models import Agreement
from ...forms.register import RegisterForm
from ...registration import (
get_registration_result_json,
save_user_agreements,
send_welcome_email,
)
from ...setupnewuser import setup_new_user
User = get_user_model()
@csrf_protect
def create_endpoint(request):
if request.settings.account_activation == "closed":
raise PermissionDenied(
pgettext(
"user register api", "New users registrations are currently closed."
)
)
request_data = request.data
if not isinstance(request_data, dict):
request_data = {}
form = RegisterForm(
request_data, request=request, agreements=Agreement.objects.get_agreements()
)
try:
if form.is_valid():
captcha.test_request(request)
except ValidationError as e:
form.add_error("captcha", e)
if not form.is_valid():
return Response(form.errors, status=status.HTTP_400_BAD_REQUEST)
activation_kwargs = {}
if request.settings.account_activation == "user":
activation_kwargs = {"requires_activation": User.ACTIVATION_USER}
elif request.settings.account_activation == "admin":
activation_kwargs = {"requires_activation": User.ACTIVATION_ADMIN}
try:
new_user = User.objects.create_user(
form.cleaned_data["username"],
form.cleaned_data["email"],
form.cleaned_data["password"],
joined_from_ip=request.user_ip,
**activation_kwargs
)
except IntegrityError:
return Response(
{
"__all__": pgettext(
"user register api", "Please try resubmitting the form."
)
},
status=status.HTTP_400_BAD_REQUEST,
)
setup_new_user(request.settings, new_user)
save_user_agreements(new_user, form)
send_welcome_email(request, new_user)
if new_user.requires_activation == User.ACTIVATION_NONE:
authenticated_user = authenticate(
username=new_user.email, password=form.cleaned_data["password"]
)
login(request, authenticated_user)
return Response(get_registration_result_json(new_user))
| 2,632
|
Python
|
.py
| 69
| 30.811594
| 84
| 0.674118
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,436
|
list.py
|
rafalp_Misago/misago/users/api/userendpoints/list.py
|
from django.contrib.auth import get_user_model
from django.shortcuts import get_object_or_404
from rest_framework.response import Response
from ....core.shortcuts import get_int_or_404
from ...models import Rank
from ...serializers import UserCardSerializer
from ...viewmodels import ActivePosters, RankUsers
User = get_user_model()
def active(request):
users = ActivePosters(request)
return Response(users.get_frontend_context())
def rank_users(request):
rank_pk = get_int_or_404(request.query_params.get("rank"))
rank = get_object_or_404(Rank.objects, pk=rank_pk, is_tab=True)
page = get_int_or_404(request.GET.get("page", 0))
if page == 1:
page = 0 # api allows explicit first page
users = RankUsers(request, rank, page)
return Response(users.get_frontend_context())
LISTS = {"active": active}
def list_endpoint(request):
list_type = request.query_params.get("list")
list_handler = LISTS.get(list_type)
if list_handler:
return list_handler(request)
return rank_users(request)
ScoredUserSerializer = UserCardSerializer.extend_fields("meta")
| 1,123
|
Python
|
.py
| 27
| 37.666667
| 67
| 0.741906
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,437
|
username.py
|
rafalp_Misago/misago/users/api/userendpoints/username.py
|
from django.db import IntegrityError
from django.utils.translation import pgettext
from rest_framework import status
from rest_framework.response import Response
from ...namechanges import get_username_options
from ...serializers import ChangeUsernameSerializer
def username_endpoint(request):
if request.method == "POST":
return change_username(request)
options = get_username_options_from_request(request)
return options_response(options)
def get_username_options_from_request(request):
return get_username_options(request.settings, request.user, request.user_acl)
def options_response(options):
if options["next_on"]:
options["next_on"] = options["next_on"].isoformat()
return Response(options)
def change_username(request):
options = get_username_options_from_request(request)
if not options["changes_left"]:
return Response(
{
"detail": pgettext(
"change username api",
"You can't change your username now.",
),
"options": options,
},
status=status.HTTP_400_BAD_REQUEST,
)
serializer = ChangeUsernameSerializer(
data=request.data, context={"settings": request.settings, "user": request.user}
)
if not serializer.is_valid():
return Response(
{"detail": serializer.errors["non_field_errors"][0]},
status=status.HTTP_400_BAD_REQUEST,
)
try:
serializer.change_username(changed_by=request.user)
updated_options = get_username_options_from_request(request)
if updated_options["next_on"]:
updated_options["next_on"] = updated_options["next_on"].isoformat()
return Response(
{
"username": request.user.username,
"slug": request.user.slug,
"options": updated_options,
}
)
except IntegrityError:
return Response(
{
"detail": pgettext(
"change username api",
"Error changing username. Please try again.",
)
},
status=status.HTTP_400_BAD_REQUEST,
)
def moderate_username_endpoint(request, profile):
if request.method == "POST":
serializer = ChangeUsernameSerializer(
data=request.data, context={"settings": request.settings, "user": profile}
)
if not serializer.is_valid():
return Response(
{"detail": serializer.errors["non_field_errors"][0]},
status=status.HTTP_400_BAD_REQUEST,
)
try:
serializer.change_username(changed_by=request.user)
return Response({"username": profile.username, "slug": profile.slug})
except IntegrityError:
return Response(
{
"detail": pgettext(
"change username api",
"Error changing username. Please try again.",
)
},
status=status.HTTP_400_BAD_REQUEST,
)
return Response(
{
"length_min": request.settings.username_length_min,
"length_max": request.settings.username_length_max,
}
)
| 3,370
|
Python
|
.py
| 89
| 27.134831
| 87
| 0.589029
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,438
|
auth.py
|
rafalp_Misago/misago/users/forms/auth.py
|
from django import forms
from django.contrib.auth import authenticate, get_user_model
from django.contrib.auth.forms import AuthenticationForm as BaseAuthenticationForm
from django.core.exceptions import ValidationError
from django.core.validators import validate_email
from django.utils.translation import pgettext, pgettext_lazy
from ..bans import get_user_ban
User = get_user_model()
class MisagoAuthMixin:
error_messages = {
"empty_data": pgettext_lazy("auth form", "Fill out all fields."),
"invalid_login": pgettext_lazy("auth form", "Login or password is incorrect."),
"inactive_user": pgettext_lazy(
"auth form",
"You have to activate your account before you can sign in.",
),
"inactive_admin": pgettext_lazy(
"auth form",
"A site administrator has to activate your account before you will be able to sign in.",
),
}
def confirm_user_active(self, user):
if user.requires_activation_by_admin:
raise ValidationError(
self.error_messages["inactive_admin"], code="inactive_admin"
)
if user.requires_activation_by_user:
raise ValidationError(
self.error_messages["inactive_user"], code="inactive_user"
)
def confirm_user_not_banned(self, user):
if not user.is_misago_admin:
self.user_ban = get_user_ban(user, self.request.cache_versions)
if self.user_ban:
raise ValidationError("", code="banned")
def get_errors_dict(self):
error = self.errors.as_data()["__all__"][0]
if error.code == "banned":
error.message = self.user_ban.ban.get_serialized_message()
else:
error.message = error.messages[0]
return {"detail": error.message, "code": error.code}
class AuthenticationForm(MisagoAuthMixin, BaseAuthenticationForm):
"""
Base class for authenticating users, Floppy-forms and
Misago login field compliant
"""
username = forms.CharField(
label=pgettext_lazy("login form", "Username or email"),
required=False,
max_length=254,
)
password = forms.CharField(
label=pgettext_lazy("login form", "Password"),
strip=False,
required=False,
widget=forms.PasswordInput,
)
def __init__(self, *args, request=None, **kwargs):
self.user_ban = None
self.request = request
super().__init__(request, *args, **kwargs)
def clean(self):
username = self.cleaned_data.get("username")
password = self.cleaned_data.get("password")
if not username or not password:
raise ValidationError(self.error_messages["empty_data"], code="empty_data")
self.user_cache = authenticate(username=username, password=password)
if self.user_cache is None or not self.user_cache.is_active:
raise ValidationError(
self.error_messages["invalid_login"], code="invalid_login"
)
self.confirm_login_allowed(self.user_cache)
return self.cleaned_data
def confirm_login_allowed(self, user):
self.confirm_user_active(user)
self.confirm_user_not_banned(user)
class AdminAuthenticationForm(AuthenticationForm):
required_css_class = "required"
def __init__(self, *args, **kwargs):
self.error_messages.update(
{
"not_staff": pgettext_lazy(
"admin login form", "Your account does not have admin privileges."
)
}
)
super().__init__(*args, **kwargs)
def confirm_login_allowed(self, user):
if not user.is_misago_admin:
raise forms.ValidationError(
self.error_messages["not_staff"], code="not_staff"
)
class GetUserForm(MisagoAuthMixin, forms.Form):
email = forms.CharField()
def clean(self):
data = super().clean()
email = data.get("email")
if not email or len(email) > 250:
raise forms.ValidationError(
pgettext_lazy("auth email form", "Enter e-mail address."),
code="empty_email",
)
try:
validate_email(email)
except forms.ValidationError:
raise forms.ValidationError(
pgettext_lazy("auth email form", "Entered e-mail is invalid."),
code="invalid_email",
)
try:
user = User.objects.get_by_email(data["email"])
if not user.is_active:
raise User.DoesNotExist()
self.user_cache = user
except User.DoesNotExist:
raise forms.ValidationError(
pgettext_lazy("auth email form", "No user with this e-mail exists."),
code="not_found",
)
self.confirm_allowed(user)
return data
def confirm_allowed(self, user):
"""override this method to include additional checks"""
class ResendActivationForm(GetUserForm):
def confirm_allowed(self, user):
username_format = {"user": user.username}
if not user.requires_activation:
message = pgettext(
"resend activation form", "%(user)s, your account is already active."
)
raise forms.ValidationError(
message % username_format, code="already_active"
)
if user.requires_activation_by_admin:
message = pgettext(
"resend activation form",
"%(user)s, only administrator may activate your account.",
)
raise forms.ValidationError(
message % username_format, code="inactive_admin"
)
class ResetPasswordForm(GetUserForm):
error_messages = {
"inactive_user": pgettext_lazy(
"reset password form",
"You have to activate your account before you will be able to request new password.",
),
"inactive_admin": pgettext_lazy(
"reset password form",
"Administrator has to activate your account before you will be able to request new password.",
),
}
def confirm_allowed(self, user):
self.confirm_user_active(user)
| 6,353
|
Python
|
.py
| 155
| 30.993548
| 106
| 0.612411
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,439
|
register.py
|
rafalp_Misago/misago/users/forms/register.py
|
from django import forms
from django.contrib.auth import get_user_model
from django.contrib.auth.password_validation import validate_password
from django.core.exceptions import ValidationError
from django.utils.translation import pgettext
from ..bans import get_email_ban, get_ip_ban, get_username_ban
from ..validators import validate_email, validate_new_registration, validate_username
User = get_user_model()
class BaseRegisterForm(forms.Form):
username = forms.CharField()
email = forms.CharField(validators=[validate_email])
terms_of_service = forms.IntegerField(required=False)
privacy_policy = forms.IntegerField(required=False)
def __init__(self, *args, **kwargs):
self.agreements = kwargs.pop("agreements")
self.request = kwargs.pop("request")
super().__init__(*args, **kwargs)
def clean_username(self):
data = self.cleaned_data["username"]
validate_username(self.request.settings, data)
ban = get_username_ban(data, registration_only=True)
if ban:
if ban.user_message:
raise ValidationError(ban.user_message)
else:
raise ValidationError(
pgettext("register form", "This username is not allowed.")
)
return data
def clean_email(self):
data = self.cleaned_data["email"]
ban = get_email_ban(data, registration_only=True)
if ban:
if ban.user_message:
raise ValidationError(ban.user_message)
else:
raise ValidationError(
pgettext("register form", "This e-mail address is not allowed.")
)
return data
def clean_agreements(self, data):
for field_name, agreement in self.agreements.items():
if data.get(field_name) != agreement["id"]:
error = ValueError(
pgettext("register form", "This agreement is required.")
)
self.add_error(field_name, error)
def raise_if_ip_banned(self):
ban = get_ip_ban(self.request.user_ip, registration_only=True)
if ban:
if ban.user_message:
raise ValidationError(ban.user_message)
else:
raise ValidationError(
pgettext(
"register form",
"New registrations from your current IP address are not allowed.",
)
)
class SocialAuthRegisterForm(BaseRegisterForm):
def clean(self):
cleaned_data = super().clean()
self.clean_agreements(cleaned_data)
self.raise_if_ip_banned()
validate_new_registration(self.request, cleaned_data, self.add_error)
return cleaned_data
class RegisterForm(BaseRegisterForm):
password = forms.CharField(strip=False)
# placeholder field for setting captcha errors on form
captcha = forms.CharField(required=False)
def full_clean_password(self, cleaned_data):
if cleaned_data.get("password"):
validate_password(
cleaned_data["password"],
user=User(
username=cleaned_data.get("username"),
email=cleaned_data.get("email"),
),
)
def clean(self):
cleaned_data = super().clean()
self.clean_agreements(cleaned_data)
self.raise_if_ip_banned()
try:
self.full_clean_password(cleaned_data)
except forms.ValidationError as e:
self.add_error("password", e)
validate_new_registration(self.request, cleaned_data, self.add_error)
return cleaned_data
| 3,752
|
Python
|
.py
| 89
| 31.382022
| 90
| 0.616167
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,440
|
test_group_model.py
|
rafalp_Misago/misago/users/tests/test_group_model.py
|
from ..enums import CUSTOM_GROUP_ID_START
from ..models import Group
def test_admins_group_is_only_group_with_admin_status(
admins_group, moderators_group, members_group, guests_group
):
assert admins_group.is_admin
assert not moderators_group.is_admin
assert not members_group.is_admin
assert not guests_group.is_admin
def test_custom_group_is_not_admin(db):
group = Group.objects.create(name="Custom", slug="custom")
assert not group.is_admin
def test_standard_groups_are_protected(
admins_group, moderators_group, members_group, guests_group
):
assert admins_group.is_protected
assert moderators_group.is_protected
assert members_group.is_protected
assert guests_group.is_protected
def test_custom_group_is_not_protected(db):
group = Group.objects.create(name="Custom", slug="custom")
assert not group.is_protected
def test_custom_group_id_is_greater_than_default_groups_ids(db):
group = Group.objects.create(name="Custom", slug="custom")
assert group.id >= CUSTOM_GROUP_ID_START
| 1,057
|
Python
|
.py
| 25
| 38.32
| 64
| 0.760274
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,441
|
test_user_details_api.py
|
rafalp_Misago/misago/users/tests/test_user_details_api.py
|
from django.urls import reverse
from ...acl.test import patch_user_acl
from ..test import AuthenticatedUserTestCase, create_test_user
class UserDetailsApiTests(AuthenticatedUserTestCase):
def test_api_has_no_showstoppers(self):
"""api outputs response for freshly created user"""
response = self.client.get(
reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()["edit"])
def test_api_has_no_showstoppers_old_user(self):
"""api outputs response for freshly created user"""
self.user.profile_fields = {
"gender": "f",
"bio": "Lorem ipsum dolor met, sit amet elit, si vis pacem bellum.",
}
self.user.save()
response = self.client.get(
reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()["edit"])
def test_other_user(self):
"""api handles scenario when its other user looking at profile"""
user = create_test_user("Other_User", "otheruser@example.com")
api_link = reverse("misago:api:user-details", kwargs={"pk": user.pk})
# moderator has permission to edit details
with patch_user_acl({"can_moderate_profile_details": True}):
response = self.client.get(api_link)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.json()["edit"])
# non-moderator has no permission to edit details
with patch_user_acl({"can_moderate_profile_details": False}):
response = self.client.get(api_link)
self.assertEqual(response.status_code, 200)
self.assertFalse(response.json()["edit"])
def test_nonexistant_user(self):
"""api handles nonexistant users"""
api_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk + 123})
response = self.client.get(api_link)
self.assertEqual(response.status_code, 404)
| 2,129
|
Python
|
.py
| 42
| 41.595238
| 88
| 0.649157
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,442
|
test_bans.py
|
rafalp_Misago/misago/users/tests/test_bans.py
|
from datetime import timedelta
from django.test import TestCase
from django.utils import timezone
from ...conftest import get_cache_versions
from ..bans import (
ban_ip,
ban_user,
get_email_ban,
get_ip_ban,
get_request_ip_ban,
get_user_ban,
get_username_ban,
)
from ..models import Ban
from ..test import create_test_user
cache_versions = get_cache_versions()
class GetBanTests(TestCase):
def test_get_username_ban(self):
"""get_username_ban returns valid ban"""
nonexistent_ban = get_username_ban("nonexistent")
self.assertIsNone(nonexistent_ban)
Ban.objects.create(
banned_value="expired", expires_on=timezone.now() - timedelta(days=7)
)
expired_ban = get_username_ban("expired")
self.assertIsNone(expired_ban)
Ban.objects.create(banned_value="wrongtype", check_type=Ban.EMAIL)
wrong_type_ban = get_username_ban("wrongtype")
self.assertIsNone(wrong_type_ban)
valid_ban = Ban.objects.create(
banned_value="admi*", expires_on=timezone.now() + timedelta(days=7)
)
self.assertEqual(get_username_ban("admiral").pk, valid_ban.pk)
registration_ban = Ban.objects.create(
banned_value="mod*",
expires_on=timezone.now() + timedelta(days=7),
registration_only=True,
)
self.assertIsNone(get_username_ban("moderator"))
self.assertEqual(get_username_ban("moderator", True).pk, registration_ban.pk)
def test_get_email_ban(self):
"""get_email_ban returns valid ban"""
nonexistent_ban = get_email_ban("non@existent.com")
self.assertIsNone(nonexistent_ban)
Ban.objects.create(
banned_value="ex@pired.com",
check_type=Ban.EMAIL,
expires_on=timezone.now() - timedelta(days=7),
)
expired_ban = get_email_ban("ex@pired.com")
self.assertIsNone(expired_ban)
Ban.objects.create(banned_value="wrong@type.com", check_type=Ban.IP)
wrong_type_ban = get_email_ban("wrong@type.com")
self.assertIsNone(wrong_type_ban)
valid_ban = Ban.objects.create(
banned_value="*.ru",
check_type=Ban.EMAIL,
expires_on=timezone.now() + timedelta(days=7),
)
self.assertEqual(get_email_ban("banned@mail.ru").pk, valid_ban.pk)
registration_ban = Ban.objects.create(
banned_value="*.ua",
check_type=Ban.EMAIL,
expires_on=timezone.now() + timedelta(days=7),
registration_only=True,
)
self.assertIsNone(get_email_ban("banned@mail.ua"))
self.assertEqual(get_email_ban("banned@mail.ua", True).pk, registration_ban.pk)
def test_get_ip_ban(self):
"""get_ip_ban returns valid ban"""
nonexistent_ban = get_ip_ban("123.0.0.1")
self.assertIsNone(nonexistent_ban)
Ban.objects.create(
banned_value="124.0.0.1",
check_type=Ban.IP,
expires_on=timezone.now() - timedelta(days=7),
)
expired_ban = get_ip_ban("124.0.0.1")
self.assertIsNone(expired_ban)
Ban.objects.create(banned_value="wrongtype", check_type=Ban.EMAIL)
wrong_type_ban = get_ip_ban("wrongtype")
self.assertIsNone(wrong_type_ban)
valid_ban = Ban.objects.create(
banned_value="125.0.0.*",
check_type=Ban.IP,
expires_on=timezone.now() + timedelta(days=7),
)
self.assertEqual(get_ip_ban("125.0.0.1").pk, valid_ban.pk)
registration_ban = Ban.objects.create(
banned_value="188.*",
check_type=Ban.IP,
expires_on=timezone.now() + timedelta(days=7),
registration_only=True,
)
self.assertIsNone(get_ip_ban("188.12.12.41"))
self.assertEqual(get_ip_ban("188.12.12.41", True).pk, registration_ban.pk)
class UserBansTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com")
def test_no_ban(self):
"""user is not caught by ban"""
self.assertIsNone(get_user_ban(self.user, cache_versions))
self.assertFalse(self.user.ban_cache.is_banned)
def test_permanent_ban(self):
"""user is caught by permanent ban"""
Ban.objects.create(
banned_value="User",
user_message="User reason",
staff_message="Staff reason",
)
user_ban = get_user_ban(self.user, cache_versions)
self.assertIsNotNone(user_ban)
self.assertEqual(user_ban.user_message, "User reason")
self.assertEqual(user_ban.staff_message, "Staff reason")
self.assertTrue(self.user.ban_cache.is_banned)
def test_temporary_ban(self):
"""user is caught by temporary ban"""
Ban.objects.create(
banned_value="us*",
user_message="User reason",
staff_message="Staff reason",
expires_on=timezone.now() + timedelta(days=7),
)
user_ban = get_user_ban(self.user, cache_versions)
self.assertIsNotNone(user_ban)
self.assertEqual(user_ban.user_message, "User reason")
self.assertEqual(user_ban.staff_message, "Staff reason")
self.assertTrue(self.user.ban_cache.is_banned)
def test_expired_ban(self):
"""user is not caught by expired ban"""
Ban.objects.create(
banned_value="us*", expires_on=timezone.now() - timedelta(days=7)
)
self.assertIsNone(get_user_ban(self.user, cache_versions))
self.assertFalse(self.user.ban_cache.is_banned)
def test_expired_non_flagged_ban(self):
"""user is not caught by expired but checked ban"""
Ban.objects.create(
banned_value="us*", expires_on=timezone.now() - timedelta(days=7)
)
Ban.objects.update(is_checked=True)
self.assertIsNone(get_user_ban(self.user, cache_versions))
self.assertFalse(self.user.ban_cache.is_banned)
class MockRequest:
def __init__(self):
self.user_ip = "127.0.0.1"
self.session = {}
self.cache_versions = cache_versions
class RequestIPBansTests(TestCase):
def test_no_ban(self):
"""no ban found"""
ip_ban = get_request_ip_ban(MockRequest())
self.assertIsNone(ip_ban)
def test_permanent_ban(self):
"""ip is caught by permanent ban"""
Ban.objects.create(
check_type=Ban.IP, banned_value="127.0.0.1", user_message="User reason"
)
ip_ban = get_request_ip_ban(MockRequest())
self.assertTrue(ip_ban["is_banned"])
self.assertEqual(ip_ban["ip"], "127.0.0.1")
self.assertEqual(ip_ban["message"], "User reason")
# repeated call uses cache
get_request_ip_ban(MockRequest())
def test_temporary_ban(self):
"""ip is caught by temporary ban"""
Ban.objects.create(
check_type=Ban.IP,
banned_value="127.0.0.1",
user_message="User reason",
expires_on=timezone.now() + timedelta(days=7),
)
ip_ban = get_request_ip_ban(MockRequest())
self.assertTrue(ip_ban["is_banned"])
self.assertEqual(ip_ban["ip"], "127.0.0.1")
self.assertEqual(ip_ban["message"], "User reason")
# repeated call uses cache
get_request_ip_ban(MockRequest())
def test_expired_ban(self):
"""ip is not caught by expired ban"""
Ban.objects.create(
check_type=Ban.IP,
banned_value="127.0.0.1",
user_message="User reason",
expires_on=timezone.now() - timedelta(days=7),
)
ip_ban = get_request_ip_ban(MockRequest())
self.assertIsNone(ip_ban)
# repeated call uses cache
get_request_ip_ban(MockRequest())
class BanUserTests(TestCase):
def test_ban_user(self):
"""ban_user utility bans user"""
user = create_test_user("User", "user@example.com")
ban = ban_user(user, "User reason", "Staff reason")
self.assertEqual(ban.user_message, "User reason")
self.assertEqual(ban.staff_message, "Staff reason")
db_ban = get_user_ban(user, cache_versions)
self.assertEqual(ban.pk, db_ban.ban_id)
class BanIpTests(TestCase):
def test_ban_ip(self):
"""ban_ip utility bans IP address"""
ban = ban_ip("127.0.0.1", "User reason", "Staff reason")
self.assertEqual(ban.user_message, "User reason")
self.assertEqual(ban.staff_message, "Staff reason")
db_ban = get_ip_ban("127.0.0.1")
self.assertEqual(ban.pk, db_ban.pk)
| 8,719
|
Python
|
.py
| 207
| 33.043478
| 87
| 0.619442
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,443
|
test_bio_profilefield.py
|
rafalp_Misago/misago/users/tests/test_bio_profilefield.py
|
from django.contrib.auth import get_user_model
from django.urls import reverse
from ...admin.test import AdminTestCase
User = get_user_model()
class BioProfileFieldTests(AdminTestCase):
def setUp(self):
super().setUp()
self.test_link = reverse("misago:admin:users:edit", kwargs={"pk": self.user.pk})
def test_field_displays_in_admin(self):
"""field displays in admin"""
response = self.client.get(self.test_link)
self.assertContains(response, 'name="bio"')
def test_admin_clears_field(self):
"""admin form allows admins to clear field"""
self.user.profile_fields["bio"] = "Exists!"
self.user.save()
self.reload_user()
self.assertEqual(self.user.profile_fields["bio"], "Exists!")
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertEqual(response.status_code, 302)
self.reload_user()
self.assertEqual(self.user.profile_fields["bio"], "")
def test_admin_edits_field(self):
"""admin form allows admins to edit field"""
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"bio": "Edited field!",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertEqual(response.status_code, 302)
self.reload_user()
self.assertEqual(self.user.profile_fields["bio"], "Edited field!")
def test_admin_search_field(self):
"""admin users search searches this field"""
test_link = reverse("misago:admin:users:index")
response = self.client.get("%s?redirected=1&profilefields=Ipsum" % test_link)
self.assertContains(response, "No users matching criteria exist.")
self.user.profile_fields["bio"] = "Lorem Ipsum Dolor Met"
self.user.save()
response = self.client.get("%s?redirected=1&profilefields=Ipsum" % test_link)
self.assertNotContains(response, "No users matching criteria exist.")
def test_field_display(self):
"""field displays on user profile when filled in"""
test_link = reverse(
"misago:user-details", kwargs={"pk": self.user.pk, "slug": self.user.slug}
)
response = self.client.get(test_link)
self.assertNotContains(response, "Bio")
self.user.profile_fields["bio"] = "I am Bob!\n\nThis is <b>my</b> bio!"
self.user.save()
response = self.client.get(test_link)
self.assertContains(response, "Bio")
self.assertContains(response, "<p>I am Bob!</p>")
self.assertContains(response, "<p>This is <b>my</b> bio!</p>")
def test_field_display_json(self):
"""field is included in display json"""
test_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
}
],
)
self.user.profile_fields["bio"] = "I am Bob!\n\nThis is <b>my</b> bio!"
self.user.save()
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "Personal",
"fields": [
{
"fieldname": "bio",
"name": "Bio",
"html": (
"<p>I am Bob!</p>\n\n"
"<p>This is <b>my</b> bio!</p>"
),
}
],
},
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
},
],
)
def test_api_returns_field_json(self):
"""field json is returned from API"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
found_field = None
for group in response.json():
for field in group["fields"]:
if field["fieldname"] == "bio":
found_field = field
self.assertEqual(
found_field,
{
"fieldname": "bio",
"label": "Bio",
"help_text": None,
"input": {"type": "textarea"},
"initial": "",
},
)
def test_api_clears_field(self):
"""field can be cleared via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
self.user.profile_fields["bio"] = "Exists!"
self.user.save()
self.reload_user()
self.assertEqual(self.user.profile_fields["bio"], "Exists!")
response = self.client.post(test_link, data={})
self.assertEqual(response.status_code, 200)
self.reload_user()
self.assertEqual(self.user.profile_fields["bio"], "")
def test_api_edits_field(self):
"""field can be edited via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.post(test_link, data={"bio": "Lorem Ipsum!"})
self.assertEqual(response.status_code, 200)
self.reload_user()
self.assertEqual(self.user.profile_fields["bio"], "Lorem Ipsum!")
| 7,872
|
Python
|
.py
| 180
| 30.422222
| 88
| 0.512278
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,444
|
test_update_group_description.py
|
rafalp_Misago/misago/users/tests/test_update_group_description.py
|
import pytest
from ..groups import update_group_description
def test_update_group_description_updates_group_description_attribute(custom_group):
update_group_description(custom_group, meta="Updated")
assert custom_group.description.meta == "Updated"
def test_update_group_description_updates_group_description_in_database(custom_group):
update_group_description(custom_group, meta="Updated")
custom_group.description.refresh_from_db()
assert custom_group.description.meta == "Updated"
def test_update_group_description_raises_type_error_for_invalid_attribute(custom_group):
with pytest.raises(TypeError):
update_group_description(custom_group, invalid_attr=True)
| 703
|
Python
|
.py
| 12
| 54.25
| 88
| 0.795022
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,445
|
test_deletemarkedusers.py
|
rafalp_Misago/misago/users/tests/test_deletemarkedusers.py
|
from io import StringIO
import pytest
from django.contrib.auth import get_user_model
from django.core.management import call_command
from django.test import TestCase
from ...conf.test import override_dynamic_settings
from ..management.commands import deletemarkedusers
from ..models import DeletedUser
from ..test import create_test_user
User = get_user_model()
def call_deletemarkedusers():
out = StringIO()
call_command(deletemarkedusers.Command(), stdout=out)
return out.getvalue().splitlines()[0].strip()
@pytest.fixture
def user_marked_for_delete(user):
user.mark_for_delete()
return user
def test_deletemarkedusers_command_deletes_marked_user(user_marked_for_delete):
output = call_deletemarkedusers()
assert output == "Deleted users: 1"
with pytest.raises(User.DoesNotExist):
user_marked_for_delete.refresh_from_db()
def test_deletemarkedusers_command_records_user_deletion(user_marked_for_delete):
output = call_deletemarkedusers()
assert output == "Deleted users: 1"
DeletedUser.objects.get(deleted_by=DeletedUser.DELETED_BY_SELF)
@override_dynamic_settings(allow_delete_own_account=False)
def test_deletemarkedusers_command_ignores_delete_own_account_setting_change(
user_marked_for_delete,
):
output = call_deletemarkedusers()
assert output == "Deleted users: 1"
with pytest.raises(User.DoesNotExist):
user_marked_for_delete.refresh_from_db()
def test_deletemarkedusers_command_excludes_users_not_marked_for_deletion(user):
output = call_deletemarkedusers()
assert output == "Deleted users: 0"
user.refresh_from_db()
def test_deletemarkedusers_command_excludes_staff_users(user_marked_for_delete):
"""staff users are extempt from deletion"""
user_marked_for_delete.is_staff = True
user_marked_for_delete.save()
output = call_deletemarkedusers()
assert output == "Deleted users: 0"
user_marked_for_delete.refresh_from_db()
def test_deletemarkedusers_command_excludes_admins(
user_marked_for_delete, admins_group
):
"""staff users are extempt from deletion"""
user_marked_for_delete.set_groups(admins_group)
user_marked_for_delete.save()
output = call_deletemarkedusers()
assert output == "Deleted users: 0"
user_marked_for_delete.refresh_from_db()
def test_deletemarkedusers_command_excludes_root_admins(user_marked_for_delete):
"""staff users are extempt from deletion"""
user_marked_for_delete.is_misago_root = True
user_marked_for_delete.save()
output = call_deletemarkedusers()
assert output == "Deleted users: 0"
user_marked_for_delete.refresh_from_db()
| 2,664
|
Python
|
.py
| 62
| 38.822581
| 81
| 0.759627
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,446
|
test_user_avatar_api.py
|
rafalp_Misago/misago/users/tests/test_user_avatar_api.py
|
import json
import os
from pathlib import Path
from ...acl.test import patch_user_acl
from ...conf import settings
from ...conf.test import override_dynamic_settings
from ..avatars import gallery, store
from ..models import AvatarGallery
from ..test import AuthenticatedUserTestCase, create_test_user
TESTFILES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "testfiles")
TEST_AVATAR_PATH = os.path.join(TESTFILES_DIR, "avatar.png")
class UserAvatarTests(AuthenticatedUserTestCase):
"""tests for user avatar RPC (/api/users/1/avatar/)"""
def setUp(self):
super().setUp()
self.link = "/api/users/%s/avatar/" % self.user.pk
self.client.post(self.link, data={"avatar": "generated"})
def get_current_user(self):
self.user.refresh_from_db()
return self.user
def assertOldAvatarsAreDeleted(self, user):
self.assertEqual(user.avatar_set.count(), len(settings.MISAGO_AVATARS_SIZES))
@override_dynamic_settings(allow_custom_avatars=False)
def test_avatars_off(self):
"""custom avatars are not allowed"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
options = response.json()
self.assertTrue(options["generated"])
self.assertFalse(options["gravatar"])
self.assertFalse(options["crop_src"])
self.assertFalse(options["crop_tmp"])
self.assertFalse(options["upload"])
self.assertFalse(options["galleries"])
@override_dynamic_settings(allow_custom_avatars=True)
def test_avatars_on(self):
"""custom avatars are allowed"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
options = response.json()
self.assertTrue(options["generated"])
self.assertTrue(options["gravatar"])
self.assertFalse(options["crop_src"])
self.assertFalse(options["crop_tmp"])
self.assertTrue(options["upload"])
self.assertFalse(options["galleries"])
def test_gallery_exists(self):
"""api returns gallery"""
gallery.load_avatar_galleries()
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
options = response.json()
self.assertTrue(options["galleries"])
def test_avatar_locked(self):
"""requests to api error if user's avatar is locked"""
self.user.is_avatar_locked = True
self.user.avatar_lock_user_message = "Your avatar is pwnt."
self.user.save()
response = self.client.get(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{
"detail": "Your avatar is locked. You can't change it.",
"reason": "<p>Your avatar is pwnt.</p>",
},
)
def test_other_user_avatar(self):
"""requests to api error if user tries to access other user"""
self.logout_user()
response = self.client.get(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You have to sign in to perform this action."}
)
self.login_user(create_test_user("Other_User", "otheruser@example.com"))
response = self.client.get(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "You can't change other users avatars."}
)
def test_empty_requests(self):
"""empty request errors with code 400"""
response = self.client.post(self.link)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "Unknown avatar type."})
def test_failed_gravatar_request(self):
"""no gravatar RPC fails"""
self.user.email_hash = "wolololo"
self.user.save()
response = self.client.post(self.link, data={"avatar": "gravatar"})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"detail": "No Gravatar is associated with your e-mail address."},
)
def test_successful_gravatar_request(self):
"""gravatar RPC passes"""
self.user.set_email("rafio.xudb@gmail.com")
self.user.save()
response = self.client.post(self.link, data={"avatar": "gravatar"})
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json()["detail"], "Gravatar was downloaded and set as new avatar."
)
self.assertOldAvatarsAreDeleted(self.user)
def test_generation_request(self):
"""generated avatar is set"""
response = self.client.post(self.link, data={"avatar": "generated"})
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json()["detail"], "New avatar based on your account was set."
)
self.assertOldAvatarsAreDeleted(self.user)
def test_avatar_upload_and_crop(self):
"""avatar can be uploaded and cropped"""
response = self.client.post(self.link, data={"avatar": "upload"})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "No file was sent."})
with open(TEST_AVATAR_PATH, "rb") as avatar:
response = self.client.post(
self.link, data={"avatar": "upload", "image": avatar}
)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertTrue(response_json["crop_tmp"])
self.assertEqual(
self.get_current_user().avatar_tmp.url, response_json["crop_tmp"]["url"]
)
avatar = Path(self.get_current_user().avatar_tmp.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.is_file())
response = self.client.post(
self.link,
json.dumps(
{"avatar": "crop_tmp", "crop": {"offset": {"x": 0, "y": 0}, "zoom": 1}}
),
content_type="application/json",
)
response_json = response.json()
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["detail"], "Uploaded avatar was set.")
self.assertFalse(self.get_current_user().avatar_tmp)
self.assertOldAvatarsAreDeleted(self.user)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertTrue(avatar.exists())
self.assertTrue(avatar.is_file())
response = self.client.post(
self.link,
json.dumps(
{"avatar": "crop_tmp", "crop": {"offset": {"x": 0, "y": 0}, "zoom": 1}}
),
content_type="application/json",
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": "This avatar type is not available."}
)
response = self.client.post(
self.link,
json.dumps(
{"avatar": "crop_src", "crop": {"offset": {"x": 0, "y": 0}, "zoom": 1}}
),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["detail"], "Avatar was re-cropped.")
self.assertOldAvatarsAreDeleted(self.user)
# delete user avatars, test if it deletes src and tmp
store.delete_avatar(self.get_current_user())
self.assertTrue(self.get_current_user().avatar_src.path)
avatar = Path(self.get_current_user().avatar_src.path)
self.assertFalse(avatar.exists())
self.assertFalse(avatar.is_file())
def test_gallery_set_empty_gallery(self):
"""gallery handles set avatar on empty gallery"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
response = self.client.post(
self.link, data={"avatar": "galleries", "image": 123}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": "This avatar type is not available."}
)
def test_gallery_image_validation(self):
"""gallery validates image to set"""
gallery.load_avatar_galleries()
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
# no image id is handled
response = self.client.post(self.link, data={"avatar": "galleries"})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "Incorrect image."})
# invalid id is handled
response = self.client.post(
self.link, data={"avatar": "galleries", "image": "asdsadsadsa"}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "Incorrect image."})
# nonexistant image is handled
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
options = response.json()
self.assertTrue(options["galleries"])
test_avatar = options["galleries"][0]["images"][0]["id"]
response = self.client.post(
self.link, data={"avatar": "galleries", "image": test_avatar + 5000}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "Incorrect image."})
# default gallery image is handled
AvatarGallery.objects.filter(pk=test_avatar).update(
gallery=gallery.DEFAULT_GALLERY
)
response = self.client.post(
self.link, data={"avatar": "galleries", "image": test_avatar}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "Incorrect image."})
def test_gallery_set_valid_avatar(self):
"""its possible to set avatar from gallery"""
gallery.load_avatar_galleries()
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
options = response.json()
self.assertTrue(options["galleries"])
test_avatar = options["galleries"][0]["images"][0]["id"]
response = self.client.post(
self.link, data={"avatar": "galleries", "image": test_avatar}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["detail"], "Avatar from gallery was set.")
self.assertOldAvatarsAreDeleted(self.user)
class UserAvatarModerationTests(AuthenticatedUserTestCase):
"""tests for moderate user avatar RPC (/api/users/1/moderate-avatar/)"""
def setUp(self):
super().setUp()
self.other_user = create_test_user("Other_User", "other@user.com")
self.link = "/api/users/%s/moderate-avatar/" % self.other_user.pk
@patch_user_acl({"can_moderate_avatars": 0})
def test_no_permission(self):
"""no permission to moderate avatar"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json(), {"detail": "You can't moderate avatars."})
@patch_user_acl({"can_moderate_avatars": 1})
def test_moderate_avatar(self):
"""moderate avatar"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
options = response.json()
self.assertEqual(options["is_avatar_locked"], self.other_user.is_avatar_locked)
self.assertEqual(
options["avatar_lock_user_message"],
self.other_user.avatar_lock_user_message,
)
self.assertEqual(
options["avatar_lock_staff_message"],
self.other_user.avatar_lock_staff_message,
)
response = self.client.post(
self.link,
json.dumps(
{
"is_avatar_locked": True,
"avatar_lock_user_message": "Test user message.",
"avatar_lock_staff_message": "Test staff message.",
}
),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
self.other_user.refresh_from_db()
options = response.json()
self.assertEqual(self.other_user.is_avatar_locked, True)
self.assertEqual(self.other_user.avatar_lock_user_message, "Test user message.")
self.assertEqual(
self.other_user.avatar_lock_staff_message, "Test staff message."
)
self.assertEqual(options["avatars"], self.other_user.avatars)
self.assertEqual(options["is_avatar_locked"], self.other_user.is_avatar_locked)
self.assertEqual(
options["avatar_lock_user_message"],
self.other_user.avatar_lock_user_message,
)
self.assertEqual(
options["avatar_lock_staff_message"],
self.other_user.avatar_lock_staff_message,
)
response = self.client.post(
self.link,
json.dumps(
{
"is_avatar_locked": False,
"avatar_lock_user_message": None,
"avatar_lock_staff_message": None,
}
),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
self.other_user.refresh_from_db()
self.assertFalse(self.other_user.is_avatar_locked)
self.assertIsNone(self.other_user.avatar_lock_user_message)
self.assertIsNone(self.other_user.avatar_lock_staff_message)
options = response.json()
self.assertEqual(options["avatars"], self.other_user.avatars)
self.assertEqual(options["is_avatar_locked"], self.other_user.is_avatar_locked)
self.assertEqual(
options["avatar_lock_user_message"],
self.other_user.avatar_lock_user_message,
)
self.assertEqual(
options["avatar_lock_staff_message"],
self.other_user.avatar_lock_staff_message,
)
response = self.client.post(
self.link,
json.dumps(
{
"is_avatar_locked": True,
"avatar_lock_user_message": "",
"avatar_lock_staff_message": "",
}
),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
self.other_user.refresh_from_db()
self.assertTrue(self.other_user.is_avatar_locked)
self.assertEqual(self.other_user.avatar_lock_user_message, "")
self.assertEqual(self.other_user.avatar_lock_staff_message, "")
options = response.json()
self.assertEqual(options["avatars"], self.other_user.avatars)
self.assertEqual(options["is_avatar_locked"], self.other_user.is_avatar_locked)
self.assertEqual(
options["avatar_lock_user_message"],
self.other_user.avatar_lock_user_message,
)
self.assertEqual(
options["avatar_lock_staff_message"],
self.other_user.avatar_lock_staff_message,
)
response = self.client.post(
self.link,
json.dumps({"is_avatar_locked": False}),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
self.other_user.refresh_from_db()
self.assertFalse(self.other_user.is_avatar_locked)
self.assertEqual(self.other_user.avatar_lock_user_message, "")
self.assertEqual(self.other_user.avatar_lock_staff_message, "")
options = response.json()
self.assertEqual(options["avatars"], self.other_user.avatars)
self.assertEqual(options["is_avatar_locked"], self.other_user.is_avatar_locked)
self.assertEqual(
options["avatar_lock_user_message"],
self.other_user.avatar_lock_user_message,
)
self.assertEqual(
options["avatar_lock_staff_message"],
self.other_user.avatar_lock_staff_message,
)
@patch_user_acl({"can_moderate_avatars": 1})
def test_moderate_own_avatar(self):
"""moderate own avatar"""
response = self.client.get("/api/users/%s/moderate-avatar/" % self.user.pk)
self.assertEqual(response.status_code, 200)
| 16,595
|
Python
|
.py
| 370
| 34.864865
| 88
| 0.617724
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,447
|
test_captcha_api.py
|
rafalp_Misago/misago/users/tests/test_captcha_api.py
|
from django.test import TestCase
from django.urls import reverse
from ...conf.test import override_dynamic_settings
test_qa_question = "Do you like pies?"
test_qa_help_text = 'Type in "yes".'
class AuthenticateApiTests(TestCase):
def setUp(self):
self.api_link = reverse("misago:api:captcha-question")
@override_dynamic_settings(qa_question="")
def test_api_no_qa_is_set(self):
"""qa api returns 404 if no QA question is set"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 404)
@override_dynamic_settings(
qa_question=test_qa_question, qa_help_text=test_qa_help_text
)
def test_api_get_question(self):
"""qa api returns valid QA question"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json["question"], test_qa_question)
self.assertEqual(response_json["help_text"], test_qa_help_text)
| 1,040
|
Python
|
.py
| 23
| 39.043478
| 71
| 0.69703
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,448
|
test_user_middleware.py
|
rafalp_Misago/misago/users/tests/test_user_middleware.py
|
import json
from django.urls import reverse
from ..bans import ban_ip, ban_user
from ..models import Ban
def test_user_middleware_sets_authenticated_user(user_client, user):
response = user_client.get(reverse("misago:api:auth"))
assert json.loads(response.content)["id"] == user.id
def test_user_middleware_doesnt_pass_banned_user(user_client, user):
ban_user(user)
response = user_client.get(reverse("misago:api:auth"))
assert json.loads(response.content)["id"] is None
def test_user_middleware_passes_banned_admin_user(admin_client, admin):
ban_user(admin)
response = admin_client.get(reverse("misago:api:auth"))
assert json.loads(response.content)["id"] == admin.id
def test_user_middleware_doesnt_pass_banned_ip_user(user_client):
ban_ip("127.0.0.1")
response = user_client.get(reverse("misago:api:auth"))
assert json.loads(response.content)["id"] is None
def test_user_middleware_passes_banned_ip_admin_user(admin_client, admin):
ban_ip("127.0.0.1")
response = admin_client.get(reverse("misago:api:auth"))
assert json.loads(response.content)["id"] == admin.id
def test_user_middleware_skips_registration_only_bans(user_client, user):
Ban.objects.create(
check_type=Ban.USERNAME,
banned_value="%s*" % user.username[:3],
registration_only=True,
)
response = user_client.get(reverse("misago:api:auth"))
assert json.loads(response.content)["id"] == user.id
| 1,473
|
Python
|
.py
| 31
| 42.806452
| 74
| 0.722417
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,449
|
test_auth_api.py
|
rafalp_Misago/misago/users/tests/test_auth_api.py
|
import json
from django.core import mail
from django.test import TestCase
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ..models import Ban
from ..test import create_test_user
from ..tokens import make_password_change_token
class GatewayTests(TestCase):
def test_api_invalid_credentials(self):
"""login api returns 400 on invalid POST"""
response = self.client.post(
"/api/auth/", data={"username": "nope", "password": "nope"}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"code": "invalid_login", "detail": "Login or password is incorrect."},
)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
def test_login(self):
"""api signs user in"""
user = create_test_user("User", "user@example.com", "password")
response = self.client.post(
"/api/auth/", data={"username": "User", "password": "password"}
)
self.assertEqual(response.status_code, 200)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertEqual(user_json["id"], user.id)
self.assertEqual(user_json["username"], user.username)
def test_login_whitespaces_password(self):
"""api signs user in with password left untouched"""
user = create_test_user("User", "user@example.com", " password ")
response = self.client.post(
"/api/auth/", data={"username": "User", "password": "password"}
)
self.assertEqual(response.status_code, 400)
response = self.client.post(
"/api/auth/", data={"username": "User", "password": " password "}
)
self.assertEqual(response.status_code, 200)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertEqual(user_json["id"], user.id)
self.assertEqual(user_json["username"], user.username)
def test_submit_empty(self):
"""login api errors for no body"""
response = self.client.post("/api/auth/")
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"code": "empty_data", "detail": "Fill out all fields."}
)
def test_submit_invalid(self):
"""login api errors for invalid data"""
response = self.client.post(
"/api/auth/", "false", content_type="application/json"
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"non_field_errors": [
"Invalid data. Expected a dictionary, but got bool."
]
},
)
def test_login_not_usable_password(self):
"""login api fails to sign user with not-usable password in"""
create_test_user("User", "user@example.com")
response = self.client.post(
"/api/auth/", data={"username": "User", "password": "password"}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"code": "invalid_login", "detail": "Login or password is incorrect."},
)
def test_login_banned(self):
"""login api fails to sign banned user in"""
create_test_user("User", "user@example.com", "password")
ban = Ban.objects.create(
check_type=Ban.USERNAME,
banned_value="user",
user_message="You are tragically banned.",
)
response = self.client.post(
"/api/auth/", data={"username": "User", "password": "password"}
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(response_json["code"], "banned")
self.assertEqual(response_json["detail"]["message"]["plain"], ban.user_message)
self.assertEqual(
response_json["detail"]["message"]["html"], "<p>%s</p>" % ban.user_message
)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
def test_login_ban_registration_only(self):
"""login api ignores registration-only bans"""
user = create_test_user("User", "user@example.com", "password")
Ban.objects.create(
check_type=Ban.USERNAME, banned_value="user", registration_only=True
)
response = self.client.post(
"/api/auth/", data={"username": "User", "password": "password"}
)
self.assertEqual(response.status_code, 200)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertEqual(user_json["id"], user.id)
self.assertEqual(user_json["username"], user.username)
def test_login_inactive_admin(self):
"""login api fails to sign admin-activated user in"""
create_test_user("User", "user@example.com", "password", requires_activation=1)
response = self.client.post(
"/api/auth/", data={"username": "User", "password": "password"}
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(response_json["code"], "inactive_user")
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
def test_login_inactive_user(self):
"""login api fails to sign user-activated user in"""
create_test_user("User", "user@example.com", "password", requires_activation=2)
response = self.client.post(
"/api/auth/", data={"username": "User", "password": "password"}
)
self.assertEqual(response.status_code, 400)
response_json = response.json()
self.assertEqual(response_json["code"], "inactive_admin")
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
def test_auth_api_returns_403_for_banned_ip(client, user, user_password):
Ban.objects.create(
check_type=Ban.IP,
banned_value="127.0.0.1",
user_message="IP TEST BAN",
)
response = client.post(
"/api/auth/", data={"username": user.username, "password": user_password}
)
assert response.status_code == 403
assert json.loads(response.content)["ban"]["message"]["plain"] == "IP TEST BAN"
def test_auth_api_returns_403_for_banned_user(client, user, user_password):
Ban.objects.create(
check_type=Ban.USERNAME,
banned_value=user.username,
user_message="USER TEST BAN",
)
response = client.post(
"/api/auth/", data={"username": user.username, "password": user_password}
)
assert response.status_code == 400
assert json.loads(response.content)["code"] == "banned"
def test_auth_api_authenticates_banned_admin(client, admin, user_password):
Ban.objects.create(
check_type=Ban.USERNAME,
banned_value=admin.username,
user_message="USER TEST BAN",
)
response = client.post(
"/api/auth/", data={"username": admin.username, "password": user_password}
)
assert response.status_code == 200
assert json.loads(response.content)["id"] == admin.id
def test_auth_api_returns_400_for_deactivated_user(
client, inactive_user, user_password
):
response = client.post(
"/api/auth/",
data={"username": inactive_user.username, "password": user_password},
)
assert response.status_code == 400
assert json.loads(response.content)["code"] == "invalid_login"
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_login_api_returns_403_if_oauth_is_enabled(user, user_password, client):
response = client.post(
reverse("misago:api:auth"),
{"username": user.username, "password": user_password},
)
assert response.status_code == 403
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_auth_api_returns_user_if_oauth_is_enabled(user_client):
response = user_client.get(reverse("misago:api:auth"))
assert response.status_code == 200
class UserCredentialsTests(TestCase):
def test_edge_returns_response(self):
"""api edge has no showstoppers"""
response = self.client.get("/api/auth/criteria/")
self.assertEqual(response.status_code, 200)
class SendActivationApiTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com", "password")
self.user.requires_activation = 1
self.user.save()
self.link = "/api/auth/send-activation/"
def test_submit_valid(self):
"""request activation link api sends reset link mail"""
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 200)
self.assertIn("Activate User", mail.outbox[0].subject)
def test_submit_banned(self):
"""request activation link api passes for banned users"""
Ban.objects.create(
check_type=Ban.USERNAME,
banned_value=self.user.username,
user_message="Nope!",
)
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 200)
self.assertIn("Activate User", mail.outbox[0].subject)
def test_submit_disabled(self):
"""request activation link api fails disabled users"""
self.user.is_active = False
self.user.save()
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"code": "not_found", "detail": "No user with this e-mail exists."},
)
self.assertTrue(not mail.outbox)
def test_submit_empty(self):
"""request activation link api errors for no body"""
response = self.client.post(self.link)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"code": "empty_email", "detail": "Enter e-mail address."}
)
self.assertTrue(not mail.outbox)
def test_submit_invalid_data(self):
"""login api errors for invalid data"""
response = self.client.post(self.link, "false", content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"non_field_errors": [
"Invalid data. Expected a dictionary, but got bool."
]
},
)
def test_submit_invalid_email(self):
"""request activation link api errors for invalid e-mail"""
response = self.client.post(self.link, data={"email": "fake@mail.com"})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"code": "not_found", "detail": "No user with this e-mail exists."},
)
self.assertTrue(not mail.outbox)
def test_submit_active_user(self):
"""request activation link api errors for active user"""
self.user.requires_activation = 0
self.user.save()
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"code": "already_active",
"detail": "User, your account is already active.",
},
)
def test_submit_inactive_user(self):
"""request activation link api errors for admin-activated users"""
self.user.requires_activation = 2
self.user.save()
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"code": "inactive_admin",
"detail": "User, only administrator may activate your account.",
},
)
self.assertTrue(not mail.outbox)
# but succeed for user-activated
self.user.requires_activation = 1
self.user.save()
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 200)
self.assertTrue(mail.outbox)
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_send_activation_api_returns_403_if_oauth_is_enabled(user, client):
response = client.post(
reverse("misago:api:send-activation"),
{"email": user.email},
)
assert response.status_code == 403
class SendPasswordFormApiTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com", "password")
self.link = "/api/auth/send-password-form/"
def test_submit_valid(self):
"""request change password form link api sends reset link mail"""
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 200)
self.assertIn("Change User password", mail.outbox[0].subject)
def test_submit_banned(self):
"""request change password form link api sends reset link mail"""
Ban.objects.create(
check_type=Ban.USERNAME,
banned_value=self.user.username,
user_message="Nope!",
)
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 200)
self.assertIn("Change User password", mail.outbox[0].subject)
def test_submit_disabled(self):
"""request change password form api fails disabled users"""
self.user.is_active = False
self.user.save()
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"code": "not_found", "detail": "No user with this e-mail exists."},
)
self.assertTrue(not mail.outbox)
def test_submit_empty(self):
"""request change password form link api errors for no body"""
response = self.client.post(self.link)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"code": "empty_email", "detail": "Enter e-mail address."}
)
self.assertTrue(not mail.outbox)
def test_submit_invalid(self):
"""request change password form link api errors for invalid e-mail"""
response = self.client.post(self.link, data={"email": "fake@mail.com"})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"code": "not_found", "detail": "No user with this e-mail exists."},
)
self.assertTrue(not mail.outbox)
def test_submit_invalid_data(self):
"""login api errors for invalid data"""
response = self.client.post(self.link, "false", content_type="application/json")
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"non_field_errors": [
"Invalid data. Expected a dictionary, but got bool."
]
},
)
def test_submit_inactive_user(self):
"""request change password form link api errors for inactive users"""
self.user.requires_activation = 1
self.user.save()
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"code": "inactive_user",
"detail": (
"You have to activate your account before you "
"will be able to request new password."
),
},
)
self.user.requires_activation = 2
self.user.save()
response = self.client.post(self.link, data={"email": self.user.email})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"code": "inactive_admin",
"detail": (
"Administrator has to activate your account before you "
"will be able to request new password."
),
},
)
self.assertTrue(not mail.outbox)
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_send_password_reset_api_returns_403_if_oauth_is_enabled(user, client):
response = client.post(
reverse("misago:api:send-password-form"),
{"email": user.email},
)
assert response.status_code == 403
class ChangePasswordApiTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com", "password")
self.link = "/api/auth/change-password/%s/%s/"
def test_submit_valid(self):
"""submit change password form api changes password"""
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user)),
data={"password": "n3wp4ss!"},
)
self.assertEqual(response.status_code, 200)
self.user.refresh_from_db()
self.assertTrue(self.user.check_password("n3wp4ss!"))
def test_submit_with_whitespaces(self):
"""submit change password form api changes password with whitespaces"""
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user)),
data={"password": " n3wp4ss! "},
)
self.assertEqual(response.status_code, 200)
self.user.refresh_from_db()
self.assertTrue(self.user.check_password(" n3wp4ss! "))
def test_submit_invalid_data(self):
"""login api errors for invalid data"""
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user)),
"false",
content_type="application/json",
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"non_field_errors": [
"Invalid data. Expected a dictionary, but got bool."
]
},
)
def test_invalid_token_link(self):
"""api errors on invalid user id link"""
response = self.client.post(self.link % (self.user.pk, "asda7ad89sa7d9s789as"))
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": "Form link is invalid. Please request new one."}
)
def test_banned_user_link(self):
"""request errors because user is banned"""
Ban.objects.create(
check_type=Ban.USERNAME,
banned_value=self.user.username,
user_message="Nope!",
)
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user))
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"detail": "Your link has expired. Please request new one."},
)
def test_inactive_user(self):
"""change password api errors for inactive users"""
self.user.requires_activation = 1
self.user.save()
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user))
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"detail": "Your link has expired. Please request new one."},
)
self.user.requires_activation = 2
self.user.save()
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user))
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"detail": "Your link has expired. Please request new one."},
)
def test_disabled_user(self):
"""change password api errors for disabled users"""
self.user.is_active = False
self.user.save()
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user))
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": "Form link is invalid. Please request new one."}
)
def test_submit_empty(self):
"""change password api errors for empty body"""
response = self.client.post(
self.link % (self.user.pk, make_password_change_token(self.user))
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"detail": (
"This password is too short. It must contain at least 7 characters."
)
},
)
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_reset_password_api_returns_403_if_oauth_is_enabled(user, client):
token = make_password_change_token(user)
response = client.post(
reverse("misago:api:change-forgotten-password", args=[user.pk, token]),
{"password": "n33wP4SSW00ird!!"},
)
assert response.status_code == 403
| 22,429
|
Python
|
.py
| 532
| 32.907895
| 88
| 0.612328
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,450
|
test_listusedprofilefields.py
|
rafalp_Misago/misago/users/tests/test_listusedprofilefields.py
|
from io import StringIO
from django.core.management import call_command
from django.test import TestCase
from ..management.commands import listusedprofilefields
from ..test import create_test_user
class ListUsedProfileFieldsTests(TestCase):
def test_no_fields_set(self):
"""utility has no showstoppers when no fields are set"""
create_test_user("User", "user@example.com")
out = StringIO()
call_command(listusedprofilefields.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "No profile fields are currently in use.")
def test_fields_set(self):
"""utility lists number of users that have different fields set"""
create_test_user(
"User1",
"user1@example.com",
profile_fields={"gender": "male", "bio": "Yup!"},
)
create_test_user(
"User2", "user2@example.com", profile_fields={"gender": "male"}
)
create_test_user("User3", "user3@example.com", profile_fields={"location": ""})
out = StringIO()
call_command(listusedprofilefields.Command(), stdout=out)
command_output = [l.strip() for l in out.getvalue().strip().splitlines()]
self.assertEqual(command_output, ["bio: 1", "gender: 2", "location: 1"])
| 1,360
|
Python
|
.py
| 28
| 40.678571
| 87
| 0.653061
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,451
|
test_gender_profilefield.py
|
rafalp_Misago/misago/users/tests/test_gender_profilefield.py
|
from django.contrib.auth import get_user_model
from django.urls import reverse
from ...admin.test import AdminTestCase
User = get_user_model()
class GenderProfileFieldTests(AdminTestCase):
def setUp(self):
super().setUp()
self.test_link = reverse("misago:admin:users:edit", kwargs={"pk": self.user.pk})
def test_field_displays_in_admin(self):
"""field displays in admin"""
response = self.client.get(self.test_link)
self.assertContains(response, 'name="gender"')
def test_admin_clears_field(self):
"""admin form allows admins to clear field"""
self.user.profile_fields["gender"] = "female"
self.user.save()
self.reload_user()
self.assertEqual(self.user.profile_fields["gender"], "female")
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertEqual(response.status_code, 302)
self.reload_user()
self.assertEqual(self.user.profile_fields["gender"], "")
def test_admin_validates_field(self):
"""admin form allows admins to edit field"""
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"gender": "attackcopter",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertContains(
response, "attackcopter is not one of the available choices."
)
def test_admin_edits_field(self):
"""admin form allows admins to edit field"""
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"gender": "female",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertEqual(response.status_code, 302)
self.reload_user()
self.assertEqual(self.user.profile_fields["gender"], "female")
def test_admin_search_field(self):
"""admin users search searches this field"""
test_link = reverse("misago:admin:users:index")
response = self.client.get("%s?redirected=1&profilefields=female" % test_link)
self.assertContains(response, "No users matching criteria exist.")
# search by value
self.user.profile_fields["gender"] = "female"
self.user.save()
response = self.client.get("%s?redirected=1&profilefields=female" % test_link)
self.assertNotContains(response, "No users matching criteria exist.")
# search by choice name
self.user.profile_fields["gender"] = "secret"
self.user.save()
response = self.client.get("%s?redirected=1&profilefields=telling" % test_link)
self.assertNotContains(response, "No users matching criteria exist.")
def test_field_display(self):
"""field displays on user profile when filled in"""
test_link = reverse(
"misago:user-details", kwargs={"pk": self.user.pk, "slug": self.user.slug}
)
response = self.client.get(test_link)
self.assertNotContains(response, "Gender")
self.user.profile_fields["gender"] = "secret"
self.user.save()
response = self.client.get(test_link)
self.assertContains(response, "Gender")
self.assertContains(response, "Not telling")
def test_field_outdated_hidden(self):
"""field with outdated value is hidden"""
test_link = reverse(
"misago:user-details", kwargs={"pk": self.user.pk, "slug": self.user.slug}
)
response = self.client.get(test_link)
self.assertNotContains(response, "Gender")
self.user.profile_fields["gender"] = "not valid"
self.user.save()
response = self.client.get(test_link)
self.assertNotContains(response, "Gender")
def test_field_display_json(self):
"""field is included in display json"""
test_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
}
],
)
self.user.profile_fields["gender"] = "male"
self.user.save()
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "Personal",
"fields": [
{"fieldname": "gender", "name": "Gender", "text": "Male"}
],
},
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
},
],
)
def test_field_outdated_hidden_json(self):
"""field with outdated value is removed in display json"""
test_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
}
],
)
self.user.profile_fields["gender"] = "invalid"
self.user.save()
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
}
],
)
def test_api_returns_field_json(self):
"""field json is returned from API"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
found_field = None
for group in response.json():
for field in group["fields"]:
if field["fieldname"] == "gender":
found_field = field
self.assertEqual(
found_field,
{
"fieldname": "gender",
"label": "Gender",
"help_text": None,
"input": {
"type": "select",
"choices": [
{"label": "Not specified", "value": ""},
{"label": "Not telling", "value": "secret"},
{"label": "Female", "value": "female"},
{"label": "Male", "value": "male"},
{"label": "Non-binary", "value": "enby"},
],
},
"initial": "",
},
)
def test_api_clears_field(self):
"""field can be cleared via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
self.user.profile_fields["gender"] = "secret"
self.user.save()
self.reload_user()
self.assertEqual(self.user.profile_fields["gender"], "secret")
response = self.client.post(test_link, data={})
self.assertEqual(response.status_code, 200)
self.reload_user()
self.assertEqual(self.user.profile_fields["gender"], "")
def test_api_validates_field(self):
"""field can be edited via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.post(test_link, data={"gender": "attackhelicopter"})
self.assertContains(
response,
"attackhelicopter is not one of the available choices.",
status_code=400,
)
def test_api_edits_field(self):
"""field can be edited via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.post(test_link, data={"gender": "female"})
self.assertEqual(response.status_code, 200)
self.reload_user()
self.assertEqual(self.user.profile_fields["gender"], "female")
| 11,545
|
Python
|
.py
| 268
| 29.891791
| 88
| 0.514652
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,452
|
test_signatures.py
|
rafalp_Misago/misago/users/tests/test_signatures.py
|
from unittest.mock import Mock
import pytest
from ...users import signatures
@pytest.fixture
def signature(user):
user.signature = "Test"
user.signature_parsed = "Test"
user.signature_checksum = "Test"
user.save()
def test_user_signature_and_valid_checksum_is_set(user, signature, user_acl):
request = Mock(scheme="http", get_host=Mock(return_value="127.0.0.1:800"))
signatures.set_user_signature(request, user, user_acl, "Changed")
assert user.signature == "Changed"
assert user.signature_parsed == "<p>Changed</p>"
assert user.signature_checksum
assert signatures.is_user_signature_valid(user)
def test_user_signature_is_cleared(user, signature, user_acl):
request = Mock(scheme="http", get_host=Mock(return_value="127.0.0.1:800"))
signatures.set_user_signature(request, user, user_acl, "")
assert not user.signature
assert not user.signature_parsed
assert not user.signature_checksum
def test_signature_validity_check_fails_for_incorrect_signature_checksum(
user, signature
):
assert not signatures.is_user_signature_valid(user)
| 1,112
|
Python
|
.py
| 26
| 38.692308
| 78
| 0.744879
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,453
|
test_profile_views.py
|
rafalp_Misago/misago/users/tests/test_profile_views.py
|
from django.urls import reverse
from ...acl.test import patch_user_acl
from ...categories.models import Category
from ...test import assert_contains
from ...threads import test
from ..models import Ban
from ..test import AuthenticatedUserTestCase, create_test_user
def test_deactivated_user_profile_returns_404_to_anonymous_user(client, inactive_user):
response = client.get(inactive_user.get_absolute_url())
assert response.status_code == 404
def test_deactivated_user_profile_returns_404_to_other_user(user_client, inactive_user):
response = user_client.get(inactive_user.get_absolute_url())
assert response.status_code == 404
def test_deactivated_user_profile_displays_for_admin(admin_client, inactive_user):
response = admin_client.get(inactive_user.get_absolute_url())
assert response.status_code == 302
response = admin_client.get(response["location"])
assert_contains(response, "account has been disabled")
class UserProfileViewsTests(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.link_kwargs = {"slug": self.user.slug, "pk": self.user.pk}
self.category = Category.objects.get(slug="first-category")
def test_outdated_slugs(self):
"""user profile view redirects to valid slug"""
response = self.client.get(
reverse("misago:user-posts", kwargs={"slug": "baww", "pk": self.user.pk})
)
self.assertEqual(response.status_code, 301)
def test_user_posts_list(self):
"""user profile posts list has no showstoppers"""
link = reverse("misago:user-posts", kwargs=self.link_kwargs)
response = self.client.get(link)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "You have posted no messages")
thread = test.post_thread(category=self.category, poster=self.user)
response = self.client.get(link)
self.assertEqual(response.status_code, 200)
self.assertContains(response, thread.get_absolute_url())
post = test.reply_thread(thread, poster=self.user)
other_post = test.reply_thread(thread, poster=self.user)
response = self.client.get(link)
self.assertEqual(response.status_code, 200)
self.assertContains(response, post.get_absolute_url())
self.assertContains(response, other_post.get_absolute_url())
def test_user_threads_list(self):
"""user profile threads list has no showstoppers"""
link = reverse("misago:user-threads", kwargs=self.link_kwargs)
response = self.client.get(link)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "You haven't started any threads.")
thread = test.post_thread(category=self.category, poster=self.user)
response = self.client.get(link)
self.assertEqual(response.status_code, 200)
self.assertContains(response, thread.get_absolute_url())
post = test.reply_thread(thread, poster=self.user)
other_post = test.reply_thread(thread, poster=self.user)
response = self.client.get(link)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, post.get_absolute_url())
self.assertNotContains(response, other_post.get_absolute_url())
def test_user_followers(self):
"""user profile followers list has no showstoppers"""
response = self.client.get(
reverse("misago:user-followers", kwargs=self.link_kwargs)
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "You have no followers.")
followers = []
for i in range(10):
user_data = ("Follower%s" % i, "foll%s@test.com" % i)
followers.append(create_test_user(*user_data))
self.user.followed_by.add(followers[-1])
response = self.client.get(
reverse("misago:user-followers", kwargs=self.link_kwargs)
)
self.assertEqual(response.status_code, 200)
for i in range(10):
self.assertContains(response, "Follower%s" % i)
def test_user_follows(self):
"""user profile follows list has no showstoppers"""
response = self.client.get(
reverse("misago:user-follows", kwargs=self.link_kwargs)
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "You are not following any users.")
followers = []
for i in range(10):
user_data = ("Follower%s" % i, "foll%s@test.com" % i)
followers.append(create_test_user(*user_data))
followers[-1].followed_by.add(self.user)
response = self.client.get(
reverse("misago:user-follows", kwargs=self.link_kwargs)
)
self.assertEqual(response.status_code, 200)
for i in range(10):
self.assertContains(response, "Follower%s" % i)
def test_user_details(self):
"""user details page has no showstoppers"""
response = self.client.get(
reverse("misago:user-details", kwargs=self.link_kwargs)
)
self.assertEqual(response.status_code, 200)
def test_username_history_list(self):
"""user name changes history list has no showstoppers"""
response = self.client.get(
reverse("misago:username-history", kwargs=self.link_kwargs)
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Your account has no history of name changes.")
self.user.set_username("RenamedAdmin")
self.user.save()
self.user.set_username("TestUser")
self.user.save()
response = self.client.get(
reverse("misago:username-history", kwargs=self.link_kwargs)
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "TestUser")
self.assertContains(response, "RenamedAdmin")
def test_user_ban_details(self):
"""user ban details page has no showstoppers"""
test_user = create_test_user("User", "user@example.com")
link_kwargs = {"slug": test_user.slug, "pk": test_user.pk}
with patch_user_acl({"can_see_ban_details": 0}):
response = self.client.get(reverse("misago:user-ban", kwargs=link_kwargs))
self.assertEqual(response.status_code, 404)
with patch_user_acl({"can_see_ban_details": 1}):
response = self.client.get(reverse("misago:user-ban", kwargs=link_kwargs))
self.assertEqual(response.status_code, 404)
Ban.objects.create(
banned_value=test_user.username,
user_message="User m3ss4ge.",
staff_message="Staff m3ss4ge.",
is_checked=True,
)
test_user.ban_cache.delete()
with patch_user_acl({"can_see_ban_details": 1}):
response = self.client.get(reverse("misago:user-ban", kwargs=link_kwargs))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "User m3ss4ge")
self.assertContains(response, "Staff m3ss4ge")
| 7,175
|
Python
|
.py
| 142
| 41.521127
| 88
| 0.663137
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,454
|
test_token_creation_and_validation.py
|
rafalp_Misago/misago/users/tests/test_token_creation_and_validation.py
|
from ...users import tokens
def test_token_can_be_created_for_user(user):
assert tokens.make(user, "test")
def test_token_can_be_validated(user):
token = tokens.make(user, "test")
assert tokens.is_valid(user, "test", token)
def test_token_fails_validation_for_different_type(user):
token = tokens.make(user, "activation")
assert not tokens.is_valid(user, "new_password", token)
def test_token_fails_validation_for_different_user(user, other_user):
token = tokens.make(user, "test")
assert not tokens.is_valid(other_user, "test", token)
| 572
|
Python
|
.py
| 12
| 43.666667
| 69
| 0.728261
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,455
|
test_expireuserdatadownloads.py
|
rafalp_Misago/misago/users/tests/test_expireuserdatadownloads.py
|
import os
from datetime import timedelta
from io import StringIO
from django.core.files import File
from django.core.management import call_command
from ..datadownloads import request_user_data_download
from ..management.commands import expireuserdatadownloads
from ..models import DataDownload
from ..test import AuthenticatedUserTestCase
TESTFILES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "testfiles")
TEST_FILE_PATH = os.path.join(TESTFILES_DIR, "avatar.png")
class ExpireUserDataDownloadsTests(AuthenticatedUserTestCase):
def test_delete_expired_data_download(self):
"""management command deletes expired data download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_READY
with open(TEST_FILE_PATH, "rb") as download_file:
data_download.file = File(download_file)
data_download.save()
out = StringIO()
call_command(expireuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads expired: 1")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_EXPIRED)
self.assertFalse(updated_data_download.file)
def test_skip_not_expired_data_download(self):
"""management command skips data download that expires in future"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_READY
data_download.expires_on += timedelta(hours=1)
with open(TEST_FILE_PATH, "rb") as download_file:
data_download.file = File(download_file)
data_download.save()
out = StringIO()
call_command(expireuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads expired: 0")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_READY)
self.assertTrue(updated_data_download.file)
def test_skip_pending_data_download(self):
"""management command skips pending data downloads"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_PENDING
data_download.save()
out = StringIO()
call_command(expireuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads expired: 0")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_PENDING)
def test_skip_processing_data_download(self):
"""management command skips processing data downloads"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_PROCESSING
data_download.save()
out = StringIO()
call_command(expireuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads expired: 0")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_PROCESSING)
def test_skip_expired_data_download(self):
"""management command skips pending data downloads"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_EXPIRED
data_download.save()
out = StringIO()
call_command(expireuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads expired: 0")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_EXPIRED)
def test_no_expired_data_download(self):
"""management command doesn't error when no data is expired"""
out = StringIO()
call_command(expireuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads expired: 0")
| 4,574
|
Python
|
.py
| 80
| 49.15
| 86
| 0.716204
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,456
|
test_forgottenpassword_views.py
|
rafalp_Misago/misago/users/tests/test_forgottenpassword_views.py
|
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...core.utils import encode_json_html
from ..models import Ban
from ..test import UserTestCase, create_test_user
from ..tokens import make_password_change_token
class ForgottenPasswordViewsTests(UserTestCase):
def test_guest_request_view_returns_200(self):
"""request new password view returns 200 for guests"""
response = self.client.get(reverse("misago:forgotten-password"))
self.assertEqual(response.status_code, 200)
def test_authenticated_request_view_returns_200(self):
"""request new password view returns 200 for authenticated"""
self.login_user(self.get_authenticated_user())
response = self.client.get(reverse("misago:forgotten-password"))
self.assertEqual(response.status_code, 200)
def test_authenticated_request_unusable_password_view_returns_200(self):
"""
request new password view returns 200 for authenticated with unusable password
"""
user = self.get_authenticated_user()
user.set_password(None)
user.save()
self.assertFalse(user.has_usable_password())
self.login_user(user)
response = self.client.get(reverse("misago:forgotten-password"))
self.assertEqual(response.status_code, 200)
def test_change_password_on_banned(self):
"""change banned user password errors"""
user = create_test_user(
"Other_User", "otheruser@example.com", self.USER_PASSWORD
)
Ban.objects.create(
check_type=Ban.USERNAME, banned_value="Other_User", user_message="Nope!"
)
password_token = make_password_change_token(user)
response = self.client.get(
reverse(
"misago:forgotten-password-change-form",
kwargs={"pk": user.pk, "token": password_token},
)
)
self.assertContains(response, encode_json_html("<p>Nope!</p>"), status_code=403)
def test_change_password_on_other_user(self):
"""change other user password errors"""
user = create_test_user(
"Other_User", "otheruser@example.com", self.USER_PASSWORD
)
password_token = make_password_change_token(user)
self.login_user(self.get_authenticated_user())
response = self.client.get(
reverse(
"misago:forgotten-password-change-form",
kwargs={"pk": user.pk, "token": password_token},
)
)
self.assertContains(response, "your link has expired", status_code=400)
def test_change_password_invalid_token(self):
"""invalid form token errors"""
user = create_test_user(
"Other_User", "otheruser@example.com", self.USER_PASSWORD
)
response = self.client.get(
reverse(
"misago:forgotten-password-change-form",
kwargs={"pk": user.pk, "token": "abcdfghqsads"},
)
)
self.assertContains(response, "your link is invalid", status_code=400)
def test_change_password_form(self):
"""change user password form displays for valid token"""
user = create_test_user(
"Other_User", "otheruser@example.com", self.USER_PASSWORD
)
password_token = make_password_change_token(user)
response = self.client.get(
reverse(
"misago:forgotten-password-change-form",
kwargs={"pk": user.pk, "token": password_token},
)
)
self.assertContains(response, password_token)
def test_change_password_unusable_password_form(self):
"""set user first password form displays for valid token"""
user = create_test_user("Other_User", "otheruser@example.com")
password_token = make_password_change_token(user)
response = self.client.get(
reverse(
"misago:forgotten-password-change-form",
kwargs={"pk": user.pk, "token": password_token},
)
)
self.assertContains(response, password_token)
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_forgotten_password_view_returns_403_if_oauth_is_enabled(user, client):
password_token = make_password_change_token(user)
response = client.get(
reverse(
"misago:forgotten-password-change-form",
kwargs={"pk": user.pk, "token": password_token},
)
)
assert response.status_code == 403
| 4,623
|
Python
|
.py
| 106
| 34.245283
| 88
| 0.636526
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,457
|
test_user_create_api.py
|
rafalp_Misago/misago/users/tests/test_user_create_api.py
|
from django.contrib.auth import get_user_model
from django.core import mail
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...legal.models import Agreement
from ..models import Ban, Online
from ..test import UserTestCase
User = get_user_model()
class UserCreateTests(UserTestCase):
"""tests for new user registration (POST to /api/users/)"""
def setUp(self):
super().setUp()
Agreement.objects.invalidate_cache()
self.api_link = "/api/users/"
def tearDown(self):
Agreement.objects.invalidate_cache()
def test_empty_request(self):
"""empty request errors with code 400"""
response = self.client.post(self.api_link)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"username": ["This field is required."],
"email": ["This field is required."],
"password": ["This field is required."],
},
)
def test_invalid_data(self):
"""invalid request data errors with code 400"""
response = self.client.post(
self.api_link, "false", content_type="application/json"
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"username": ["This field is required."],
"email": ["This field is required."],
"password": ["This field is required."],
},
)
def test_authenticated_request(self):
"""authentiated user request errors with code 403"""
self.login_user(self.get_authenticated_user())
response = self.client.post(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "This action is not available to signed in users."},
)
@override_dynamic_settings(account_activation="closed")
def test_registration_off_request(self):
"""registrations off request errors with code 403"""
response = self.client.post(self.api_link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(), {"detail": "New users registrations are currently closed."}
)
def test_registration_validates_ip_ban(self):
"""api validates ip ban"""
Ban.objects.create(
check_type=Ban.IP,
banned_value="127.*",
user_message="You can't register account like this.",
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 403)
def test_registration_validates_ip_registration_ban(self):
"""api validates ip registration-only ban"""
Ban.objects.create(
check_type=Ban.IP,
banned_value="127.*",
user_message="You can't register account like this.",
registration_only=True,
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"__all__": ["You can't register account like this."]}
)
def test_registration_validates_username(self):
"""api validates usernames"""
user = self.get_authenticated_user()
response = self.client.post(
self.api_link,
data={
"username": user.username,
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"username": ["This username is not available."]},
)
def test_registration_validates_username_ban(self):
"""api validates username ban"""
Ban.objects.create(
banned_value="totally*",
user_message="You can't register account like this.",
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"username": ["You can't register account like this."]}
)
def test_registration_validates_username_registration_ban(self):
"""api validates username registration-only ban"""
Ban.objects.create(
banned_value="totally*",
user_message="You can't register account like this.",
registration_only=True,
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"username": ["You can't register account like this."]}
)
def test_registration_validates_email(self):
"""api validates usernames"""
user = self.get_authenticated_user()
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": user.email,
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{"email": ["This e-mail address is not available."]},
)
def test_registration_validates_email_ban(self):
"""api validates email ban"""
Ban.objects.create(
check_type=Ban.EMAIL,
banned_value="lorem*",
user_message="You can't register account like this.",
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"email": ["You can't register account like this."]}
)
def test_registration_validates_email_registration_ban(self):
"""api validates email registration-only ban"""
Ban.objects.create(
check_type=Ban.EMAIL,
banned_value="lorem*",
user_message="You can't register account like this.",
registration_only=True,
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"email": ["You can't register account like this."]}
)
def test_registration_requires_password(self):
"""api uses django's validate_password to validate registrations"""
response = self.client.post(
self.api_link,
data={"username": "User", "email": "loremipsum@dolor.met", "password": ""},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"password": ["This field is required."]})
def test_registration_validates_password(self):
"""api uses django's validate_password to validate registrations"""
response = self.client.post(
self.api_link,
data={
"username": "User",
"email": "l.o.r.e.m.i.p.s.u.m@gmail.com",
"password": "123",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"email": ["This e-mail is not allowed."],
"password": [
(
"This password is too short. "
"It must contain at least 7 characters."
),
"This password is entirely numeric.",
],
},
)
def test_registration_validates_password_similiarity(self):
"""api uses validate_password to validate registrations"""
response = self.client.post(
self.api_link,
data={
"username": "BobBoberson",
"email": "l.o.r.e.m.i.p.s.u.m@gmail.com",
"password": "BobBoberson",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"email": ["This e-mail is not allowed."],
"password": ["The password is too similar to the username."],
},
)
@override_dynamic_settings(
captcha_type="qa", qa_question="Test", qa_answers="Lorem\nIpsum"
)
def test_registration_validates_captcha(self):
"""api validates captcha"""
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
"captcha": "dolor",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"captcha": ["Entered answer is incorrect."]})
# valid captcha
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
"captcha": "ipSUM",
},
)
self.assertEqual(response.status_code, 200)
@override_dynamic_settings(
captcha_type="qa", qa_question="", qa_answers="Lorem\n\nIpsum"
)
def test_qacaptcha_handles_empty_answers(self):
"""api validates captcha"""
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
"captcha": "",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"captcha": ["Entered answer is incorrect."]})
def test_registration_check_agreement(self):
"""api checks agreement"""
agreement = Agreement.objects.create(
type=Agreement.TYPE_TOS, text="Lorem ipsum", is_active=True
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"terms_of_service": ["This agreement is required."]}
)
# invalid agreement id
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
"terms_of_service": agreement.id + 1,
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"terms_of_service": ["This agreement is required."]}
)
# valid agreement id
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
"terms_of_service": agreement.id,
},
)
self.assertEqual(response.status_code, 200)
user = User.objects.get(email="loremipsum@dolor.met")
self.assertEqual(user.agreements, [agreement.id])
self.assertEqual(user.useragreement_set.count(), 1)
def test_registration_ignore_inactive_agreement(self):
"""api ignores inactive agreement"""
Agreement.objects.create(
type=Agreement.TYPE_TOS, text="Lorem ipsum", is_active=False
)
response = self.client.post(
self.api_link,
data={
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "LoremP4ssword",
"terms_of_service": "",
},
)
self.assertEqual(response.status_code, 200)
user = User.objects.get(email="loremipsum@dolor.met")
self.assertEqual(user.agreements, [])
self.assertEqual(user.useragreement_set.count(), 0)
def test_registration_calls_validate_new_registration(self):
"""api uses validate_new_registration to validate registrations"""
response = self.client.post(
self.api_link,
data={
"username": "User",
"email": "l.o.r.e.m.i.p.s.u.m@gmail.com",
"password": "pas123",
},
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"email": ["This e-mail is not allowed."],
"password": [
"This password is too short. It must contain at least 7 characters."
],
},
)
@override_dynamic_settings(account_activation="none")
def test_registration_creates_active_user(self):
"""api creates active and signed in user on POST"""
response = self.client.post(
self.api_link,
data={
"username": "User",
"email": "user@example.com",
"password": self.USER_PASSWORD,
},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{"activation": "active", "username": "User", "email": "user@example.com"},
)
User.objects.get_by_username("User")
test_user = User.objects.get_by_email("user@example.com")
self.assertEqual(Online.objects.filter(user=test_user).count(), 1)
self.assertTrue(test_user.check_password(self.USER_PASSWORD))
auth_json = self.client.get(reverse("misago:api:auth")).json()
self.assertTrue(auth_json["is_authenticated"])
self.assertEqual(auth_json["username"], "User")
self.assertIn("Welcome", mail.outbox[0].subject)
self.assertEqual(test_user.audittrail_set.count(), 1)
@override_dynamic_settings(account_activation="user")
def test_registration_creates_inactive_user(self):
"""api creates inactive user on POST"""
response = self.client.post(
self.api_link,
data={
"username": "User",
"email": "user@example.com",
"password": self.USER_PASSWORD,
},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{"activation": "user", "username": "User", "email": "user@example.com"},
)
auth_json = self.client.get(reverse("misago:api:auth")).json()
self.assertFalse(auth_json["is_authenticated"])
User.objects.get_by_username("User")
User.objects.get_by_email("user@example.com")
self.assertIn("Welcome", mail.outbox[0].subject)
@override_dynamic_settings(account_activation="admin")
def test_registration_creates_admin_activated_user(self):
"""api creates admin activated user on POST"""
response = self.client.post(
self.api_link,
data={
"username": "User",
"email": "user@example.com",
"password": self.USER_PASSWORD,
},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{"activation": "admin", "username": "User", "email": "user@example.com"},
)
auth_json = self.client.get(reverse("misago:api:auth")).json()
self.assertFalse(auth_json["is_authenticated"])
User.objects.get_by_username("User")
User.objects.get_by_email("user@example.com")
self.assertIn("Welcome", mail.outbox[0].subject)
@override_dynamic_settings(account_activation="none")
def test_registration_creates_user_with_whitespace_password(self):
"""api creates user with spaces around password"""
password = " %s " % self.USER_PASSWORD
response = self.client.post(
self.api_link,
data={
"username": "User",
"email": "user@example.com",
"password": password,
},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{"activation": "active", "username": "User", "email": "user@example.com"},
)
User.objects.get_by_username("User")
test_user = User.objects.get_by_email("user@example.com")
self.assertEqual(Online.objects.filter(user=test_user).count(), 1)
self.assertTrue(test_user.check_password(password))
self.assertIn("Welcome", mail.outbox[0].subject)
@override_dynamic_settings(account_activation="none")
def test_new_registrations_validators_hook_is_used_by_registration_api(
db, client, mocker
):
def validator(request, cleaned_data, add_error):
add_error("username", "ERROR FROM PLUGIN")
mocker.patch(
"misago.users.validators.hooks.new_registrations_validators", [validator]
)
response = client.post(
reverse("misago:api:user-list"),
{
"username": "User",
"email": "user@example.com",
"password": "PASSW0RD123",
},
)
assert response.status_code == 400
assert response.json() == {"username": ["ERROR FROM PLUGIN"]}
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_registration_api_returns_403_if_oauth_is_enabled(db, client):
response = client.post(
reverse("misago:api:user-list"),
{
"username": "totallyNew",
"email": "loremipsum@dolor.met",
"password": "PASSW0RD123",
},
)
assert response.status_code == 403
| 19,286
|
Python
|
.py
| 501
| 27.363273
| 88
| 0.556655
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,458
|
test_remove_old_ips_command.py
|
rafalp_Misago/misago/users/tests/test_remove_old_ips_command.py
|
from datetime import timedelta
from io import StringIO
import pytest
from django.core.management import call_command
from django.utils import timezone
from ...conf.test import override_dynamic_settings
from ..management.commands import removeoldips
IP_STORE_TIME = 2
@pytest.fixture
def user_with_ip(user):
user.joined_from_ip = "127.0.0.1"
user.save()
return user
@pytest.fixture
def user_with_old_ip(user_with_ip):
joined_on_past = timezone.now() - timedelta(days=IP_STORE_TIME + 1)
user_with_ip.joined_on = joined_on_past
user_with_ip.save()
return user_with_ip
def test_recent_user_joined_ip_is_not_removed_by_command(user_with_ip):
call_command(removeoldips.Command(), stdout=StringIO())
user_with_ip.refresh_from_db()
assert user_with_ip.joined_from_ip
@override_dynamic_settings(ip_storage_time=IP_STORE_TIME)
def test_old_user_joined_ip_is_removed_by_command(user_with_old_ip):
call_command(removeoldips.Command(), stdout=StringIO())
user_with_old_ip.refresh_from_db()
assert user_with_old_ip.joined_from_ip is None
@override_dynamic_settings(ip_storage_time=None)
def test_old_user_joined_ip_is_not_removed_by_command_if_removal_is_disabled(
user_with_old_ip,
):
call_command(removeoldips.Command(), stdout=StringIO())
user_with_old_ip.refresh_from_db()
assert user_with_old_ip.joined_from_ip
@override_dynamic_settings(ip_storage_time=IP_STORE_TIME)
def test_command_displays_message_if_old_ip_removal_is_enabled(db):
stdout = StringIO()
call_command(removeoldips.Command(), stdout=stdout)
command_output = stdout.getvalue().splitlines()[0].strip()
assert command_output == "IP addresses older than 2 days have been removed."
@override_dynamic_settings(ip_storage_time=None)
def test_command_displays_message_if_old_ip_removal_is_disabled(db):
stdout = StringIO()
call_command(removeoldips.Command(), stdout=stdout)
command_output = stdout.getvalue().splitlines()[0].strip()
assert command_output == "Old IP removal is disabled."
| 2,059
|
Python
|
.py
| 47
| 40.276596
| 80
| 0.756147
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,459
|
test_search.py
|
rafalp_Misago/misago/users/tests/test_search.py
|
import json
from django.urls import reverse
from ...acl.test import patch_user_acl
from ..test import AuthenticatedUserTestCase, create_test_user
class SearchApiTests(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.api_link = reverse("misago:api:search")
@patch_user_acl({"can_search_users": 0})
def test_no_permission(self):
"""api respects permission to search users"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertNotIn("users", [p["id"] for p in response.json()])
def test_no_query(self):
"""api handles no search query"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertIn("users", [p["id"] for p in response_json])
for provider in response_json:
if provider["id"] == "users":
self.assertEqual(provider["results"]["results"], [])
def test_empty_query(self):
"""api handles empty search query"""
response = self.client.get("%s?q=" % self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertIn("users", [p["id"] for p in response_json])
for provider in response_json:
if provider["id"] == "users":
self.assertEqual(provider["results"]["results"], [])
def test_short_query(self):
"""api handles short search query"""
response = self.client.get("%s?q=%s" % (self.api_link, self.user.username[0]))
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertIn("users", [p["id"] for p in response_json])
for provider in response_json:
if provider["id"] == "users":
results = provider["results"]["results"]
self.assertEqual(len(results), 1)
self.assertEqual(results[0]["id"], self.user.id)
def test_exact_match(self):
"""api handles exact search query"""
other_user = create_test_user("Other_User", "otheruser@example.com")
response = self.client.get("%s?q=%s" % (self.api_link, other_user.username))
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertIn("users", [p["id"] for p in response_json])
for provider in response_json:
if provider["id"] == "users":
results = provider["results"]["results"]
self.assertEqual(len(results), 1)
self.assertEqual(results[0]["id"], other_user.id)
def test_orphans_match(self):
"""api handles last three chars match query"""
other_user = create_test_user("Other_User", "otheruser@example.com")
response = self.client.get("%s?q=%s" % (self.api_link, "Other_"))
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertIn("users", [p["id"] for p in response_json])
for provider in response_json:
if provider["id"] == "users":
results = provider["results"]["results"]
self.assertEqual(len(results), 1)
self.assertEqual(results[0]["id"], other_user.id)
def test_no_match(self):
"""api handles no match"""
response = self.client.get("%s?q=BobBoberson" % self.api_link)
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertIn("users", [p["id"] for p in response_json])
for provider in response_json:
if provider["id"] == "users":
self.assertEqual(provider["results"]["results"], [])
def search_users(client, query=None):
api_link = reverse("misago:api:search")
if query:
api_link += f"?q={query}"
response = client.get(api_link)
assert response.status_code == 200
for search_results in json.loads(response.content):
if search_results["id"] == "users":
return search_results["results"]["results"]
raise AssertionError("Search results did not include users!")
def test_search_users_api_excludes_deactivated_users(client, inactive_user):
results = search_users(client, inactive_user.username)
assert results == []
def test_search_users_api_includes_deactivated_users_if_client_is_admin(
admin_client, inactive_user
):
results = search_users(admin_client, inactive_user.username)
assert results[0]["id"] == inactive_user.id
class SearchProviderApiTests(SearchApiTests):
def setUp(self):
super().setUp()
self.api_link = reverse(
"misago:api:search", kwargs={"search_provider": "users"}
)
| 4,837
|
Python
|
.py
| 100
| 39.35
| 86
| 0.626729
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,460
|
test_utils.py
|
rafalp_Misago/misago/users/tests/test_utils.py
|
from django.test import TestCase
from ..utils import hash_email
class HashEmailTests(TestCase):
def test_is_case_insensitive(self):
"""util is case insensitive"""
self.assertEqual(hash_email("abc@test.com"), hash_email("aBc@tEst.cOm"))
def test_handles_unicode(self):
"""util works with unicode strings"""
self.assertEqual(hash_email("łóć@test.com"), hash_email("ŁÓĆ@tEst.cOm"))
| 429
|
Python
|
.py
| 9
| 41.111111
| 80
| 0.697561
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,461
|
test_audittrail.py
|
rafalp_Misago/misago/users/tests/test_audittrail.py
|
from datetime import timedelta
import pytest
from django.utils import timezone
from ..audittrail import create_audit_trail, create_user_audit_trail
from ..models import AuditTrail
from ..signals import remove_old_ips
USER_IP = "13.41.51.41"
class RequestMock:
user_ip = USER_IP
def __init__(self, user):
self.user = user
@pytest.fixture
def request_mock(user):
return RequestMock(user)
def test_audit_trail_creation_raises_value_error_if_target_is_not_model_instance(
request_mock, anonymous_user
):
with pytest.raises(ValueError):
create_audit_trail(request_mock, anonymous_user)
def test_audit_trail_is_not_created_for_anonymous_users(anonymous_user, user):
request_mock = RequestMock(anonymous_user)
create_audit_trail(request_mock, user)
assert not AuditTrail.objects.exists()
def test_audit_trail_is_created(request_mock, other_user):
assert create_audit_trail(request_mock, other_user)
assert AuditTrail.objects.exists()
def test_audit_trail_is_created_with_request_data(request_mock, user, other_user):
audit_trail = create_audit_trail(request_mock, other_user)
assert audit_trail.user == user
assert audit_trail.ip_address == USER_IP
def test_audit_trail_is_created_with_generic_relation_to_target(
request_mock, user, other_user
):
audit_trail = create_audit_trail(request_mock, other_user)
assert audit_trail.content_object == other_user
def test_audit_trail_is_deleted_together_with_user(request_mock, user, other_user):
audit_trail = create_audit_trail(request_mock, other_user)
user.delete(anonymous_username="Deleted")
with pytest.raises(AuditTrail.DoesNotExist):
audit_trail.refresh_from_db()
def test_audit_trail_is_kept_after_its_target_is_deleted(request_mock, other_user):
audit_trail = create_audit_trail(request_mock, other_user)
other_user.delete(anonymous_username="Deleted")
audit_trail.refresh_from_db()
def test_deleting_audit_trail_leaves_user(request_mock, user, other_user):
audit_trail = create_audit_trail(request_mock, other_user)
audit_trail.delete()
user.refresh_from_db()
def test_deleting_audit_trail_leaves_target(request_mock, user, other_user):
audit_trail = create_audit_trail(request_mock, other_user)
audit_trail.delete()
other_user.refresh_from_db()
def test_audit_trail_can_be_created_without_request(user, other_user):
assert create_user_audit_trail(user, USER_IP, other_user)
assert AuditTrail.objects.exists()
def test_audit_trail_creation_without_request_raises_value_error_if_target_is_not_model(
user, anonymous_user
):
with pytest.raises(ValueError):
create_user_audit_trail(user, USER_IP, anonymous_user)
def test_audit_trail_without_request_is_created_with_explicit_data(user, other_user):
audit_trail = create_user_audit_trail(user, USER_IP, other_user)
assert audit_trail.user == user
assert audit_trail.ip_address == USER_IP
def test_audit_trail_without_request_is_created_with_generic_relation_to_target(
user, other_user
):
audit_trail = create_user_audit_trail(user, USER_IP, other_user)
assert audit_trail.content_object == other_user
def test_recent_audit_trail_is_not_deleted_on_signal(user, other_user):
create_user_audit_trail(user, USER_IP, other_user)
remove_old_ips.send(None, ip_storage_time=1)
assert user.audittrail_set.exists()
def test_old_audit_trail_is_deleted_on_signal(user, other_user):
audit_trail = create_user_audit_trail(user, USER_IP, other_user)
audit_trail.created_on = timezone.now() - timedelta(days=6)
audit_trail.save()
remove_old_ips.send(None, ip_storage_time=5)
assert not user.audittrail_set.exists()
| 3,750
|
Python
|
.py
| 79
| 43.21519
| 88
| 0.753719
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,462
|
test_user_username_api.py
|
rafalp_Misago/misago/users/tests/test_user_username_api.py
|
import json
from ...acl.test import patch_user_acl
from ...conf.test import override_dynamic_settings
from ..test import AuthenticatedUserTestCase, create_test_user
class UserUsernameModerationTests(AuthenticatedUserTestCase):
"""tests for moderate username RPC (/api/users/1/moderate-username/)"""
def setUp(self):
super().setUp()
self.other_user = create_test_user("Other_User", "otheruser@example.com")
self.link = "/api/users/%s/moderate-username/" % self.other_user.pk
@patch_user_acl({"can_rename_users": 0})
def test_no_permission(self):
"""no permission to moderate username"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json(), {"detail": "You can't rename users."})
response = self.client.post(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json(), {"detail": "You can't rename users."})
@patch_user_acl({"can_rename_users": 1})
@override_dynamic_settings(username_length_min=3, username_length_max=12)
def test_moderate_username(self):
"""moderate username"""
response = self.client.get(self.link)
self.assertEqual(response.status_code, 200)
options = response.json()
self.assertEqual(options["length_min"], 3)
self.assertEqual(options["length_max"], 12)
response = self.client.post(
self.link, json.dumps({"username": ""}), content_type="application/json"
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "Enter new username."})
response = self.client.post(
self.link, json.dumps({"username": "$$$"}), content_type="application/json"
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(),
{
"detail": (
"Username can only contain Latin alphabet letters, digits, "
"and an underscore sign."
),
},
)
response = self.client.post(
self.link, json.dumps({"username": "a"}), content_type="application/json"
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json(), {"detail": "Username must be at least 3 characters long."}
)
response = self.client.post(
self.link,
json.dumps({"username": "NewName"}),
content_type="application/json",
)
self.assertEqual(response.status_code, 200)
self.other_user.refresh_from_db()
self.assertEqual("NewName", self.other_user.username)
self.assertEqual("newname", self.other_user.slug)
options = response.json()
self.assertEqual(options["username"], self.other_user.username)
self.assertEqual(options["slug"], self.other_user.slug)
@patch_user_acl({"can_rename_users": 1})
def test_moderate_own_username(self):
"""moderate own username"""
response = self.client.get("/api/users/%s/moderate-username/" % self.user.pk)
self.assertEqual(response.status_code, 200)
| 3,272
|
Python
|
.py
| 70
| 37.442857
| 87
| 0.631083
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,463
|
test_testutils.py
|
rafalp_Misago/misago/users/tests/test_testutils.py
|
from django.urls import reverse
from ..test import AuthenticatedUserTestCase, SuperUserTestCase, UserTestCase
class UserTestCaseTests(UserTestCase):
def test_get_anonymous_user(self):
"""get_anonymous_user returns anon user instance"""
user = self.get_anonymous_user()
self.assertFalse(user.is_authenticated)
self.assertTrue(user.is_anonymous)
def test_get_authenticated_user(self):
"""get_authenticated_user returns auth user instance"""
user = self.get_authenticated_user()
self.assertTrue(user.is_authenticated)
self.assertFalse(user.is_anonymous)
self.assertFalse(user.is_staff)
self.assertFalse(user.is_superuser)
def test_get_superuser(self):
"""get_superuser returns auth user instance"""
user = self.get_superuser()
self.assertTrue(user.is_authenticated)
self.assertFalse(user.is_anonymous)
self.assertTrue(user.is_staff)
self.assertTrue(user.is_superuser)
def test_login_user(self):
"""login_user logs user"""
user = self.get_authenticated_user()
self.login_user(user)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertEqual(user_json["id"], user.id)
def test_login_superuser(self):
"""login_user logs superuser"""
user = self.get_superuser()
self.login_user(user)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertEqual(user_json["id"], user.id)
def test_logout_user(self):
"""logout_user logs user out"""
user = self.get_authenticated_user()
self.login_user(user)
self.logout_user()
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
def test_logout_superuser(self):
"""logout_user logs superuser out"""
user = self.get_superuser()
self.login_user(user)
self.logout_user()
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
class AuthenticatedUserTestCaseTests(AuthenticatedUserTestCase):
def test_setup(self):
"""setup executed correctly"""
response = self.client.get(reverse("misago:index"))
self.assertContains(response, self.user.username)
def test_reload_user(self):
"""reload_user reloads user"""
user_pk = self.user.pk
self.reload_user()
self.assertEqual(user_pk, self.user.pk)
class SuperUserTestCaseTests(SuperUserTestCase):
def test_setup(self):
"""setup executed correctly"""
self.assertTrue(self.user.is_staff)
self.assertTrue(self.user.is_superuser)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertEqual(user_json["id"], self.user.id)
| 3,222
|
Python
|
.py
| 75
| 34.693333
| 77
| 0.660794
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,464
|
test_active_posters_ranking.py
|
rafalp_Misago/misago/users/tests/test_active_posters_ranking.py
|
from datetime import timedelta
from django.utils import timezone
from ...conf.test import override_dynamic_settings
from ...threads.test import reply_thread
from ..activepostersranking import (
build_active_posters_ranking,
get_active_posters_ranking,
)
from ..models import ActivityRanking
from ..test import create_test_user
def test_ranking_is_emptied_if_no_users_exist(post):
assert not build_active_posters_ranking()
def test_ranking_is_emptied_if_no_posts_exist(user):
assert not build_active_posters_ranking()
@override_dynamic_settings(top_posters_ranking_length=5)
def test_recent_post_by_user_counts_to_ranking(thread, user):
reply_thread(thread, poster=user)
assert build_active_posters_ranking()
@override_dynamic_settings(top_posters_ranking_length=5)
def test_recent_post_by_removed_user_doesnt_count_to_ranking(thread):
reply_thread(thread)
assert not build_active_posters_ranking()
@override_dynamic_settings(top_posters_ranking_length=5)
def test_old_post_by_user_doesnt_count_to_ranking(thread, user):
reply_thread(thread, poster=user, posted_on=timezone.now() - timedelta(days=6))
assert not build_active_posters_ranking()
@override_dynamic_settings(top_posters_ranking_length=5)
def test_event_posts_doesnt_count_to_ranking(thread, user):
reply_thread(thread, poster=user, is_event=True)
assert not build_active_posters_ranking()
@override_dynamic_settings(top_posters_ranking_size=2)
def test_ranking_size_is_limited(thread):
for i in range(3):
user = create_test_user("User%s" % i, "user%s@example.com" % i)
reply_thread(thread, poster=user)
assert len(build_active_posters_ranking()) == 2
@override_dynamic_settings(top_posters_ranking_size=2)
def test_old_ranking_is_removed_during_build(user):
ActivityRanking.objects.create(user=user, score=1)
build_active_posters_ranking()
assert not ActivityRanking.objects.exists()
def test_empty_ranking_is_returned_from_db(db):
assert get_active_posters_ranking() == {"users": [], "users_count": 0}
def test_ranking_is_returned_from_db(user):
ActivityRanking.objects.create(user=user, score=1)
assert get_active_posters_ranking() == {"users": [user], "users_count": 1}
def test_ranked_user_is_annotated_with_score(user):
ActivityRanking.objects.create(user=user, score=1)
ranked_user = get_active_posters_ranking()["users"][0]
assert ranked_user.score == 1
def test_ranked_users_are_ordered_by_score(user, other_user):
ActivityRanking.objects.create(user=user, score=1)
ActivityRanking.objects.create(user=other_user, score=2)
assert get_active_posters_ranking() == {
"users": [other_user, user],
"users_count": 2,
}
| 2,748
|
Python
|
.py
| 57
| 44.298246
| 83
| 0.753471
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,465
|
test_loadavatargallery.py
|
rafalp_Misago/misago/users/tests/test_loadavatargallery.py
|
from io import StringIO
from django.core.management import call_command
from django.test import TestCase
from ..management.commands import loadavatargallery
from ..models import AvatarGallery
class LoadAvatarGalleryTests(TestCase):
def test_regen_blank_avatar(self):
"""command regens blank avatar"""
command = loadavatargallery.Command()
out = StringIO()
call_command(command, stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "New galleries have been loaded.")
self.assertTrue(AvatarGallery.objects.exists())
| 629
|
Python
|
.py
| 14
| 39.142857
| 75
| 0.743421
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,466
|
test_user_creation.py
|
rafalp_Misago/misago/users/tests/test_user_creation.py
|
import pytest
from django.contrib.auth import get_user_model
from ...permissions.permissionsid import get_permissions_id
from ..enums import DefaultGroupId
from ..models import Rank
from ..utils import hash_email
User = get_user_model()
def test_user_is_created(db):
user = User.objects.create_user("User", "test@example.com")
assert user.pk
assert user.joined_on
assert not user.is_staff
assert not user.is_superuser
assert not user.is_misago_root
def test_user_is_created_with_username_and_slug(db):
user = User.objects.create_user("UserName", "test@example.com")
assert user.slug == "username"
def test_user_is_created_with_normalized_email_and_email_hash(db):
user = User.objects.create_user("User", "test@eXamPLe.com")
assert user.email == "test@example.com"
assert user.email_hash == hash_email(user.email)
def test_user_is_created_with_online_tracker(db):
user = User.objects.create_user("User", "test@example.com")
assert user.online_tracker
assert user.online_tracker.last_click == user.last_login
def test_user_is_created_with_useable_password(db):
password = "password"
user = User.objects.create_user("UserUserame", "test@example.com", password)
assert user.check_password(password)
def test_user_is_created_with_default_rank(db):
user = User.objects.create_user("User", "test@example.com")
assert user.rank == Rank.objects.get_default()
def test_user_is_created_with_custom_rank(db):
rank = Rank.objects.create(name="Test rank")
user = User.objects.create_user("User", "test@example.com", rank=rank)
assert user.rank == rank
def test_user_is_created_with_default_group(db):
user = User.objects.create_user("User", "test@example.com")
assert user.group_id == DefaultGroupId.MEMBERS.value
assert user.groups_ids == [DefaultGroupId.MEMBERS.value]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_user_is_created_with_custom_group(db, moderators_group):
user = User.objects.create_user("User", "test@example.com", group=moderators_group)
assert user.group_id == moderators_group.id
assert user.groups_ids == [moderators_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_user_is_created_with_custom_group_id(db, moderators_group):
user = User.objects.create_user(
"User", "test@example.com", group_id=moderators_group.id
)
assert user.group_id == moderators_group.id
assert user.groups_ids == [moderators_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_user_is_created_with_secondary_group(db, moderators_group):
user = User.objects.create_user(
"User",
"test@example.com",
secondary_groups=[moderators_group],
)
assert user.group_id == DefaultGroupId.MEMBERS.value
assert user.groups_ids == [moderators_group.id, DefaultGroupId.MEMBERS.value]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_user_is_created_with_secondary_group_id(db, moderators_group):
user = User.objects.create_user(
"User",
"test@example.com",
secondary_groups_ids=[moderators_group.id],
)
assert user.group_id == DefaultGroupId.MEMBERS.value
assert user.groups_ids == [moderators_group.id, DefaultGroupId.MEMBERS.value]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_user_is_created_with_secondary_groups(db, admins_group, moderators_group):
user = User.objects.create_user(
"User",
"test@example.com",
secondary_groups=[admins_group, moderators_group],
)
assert user.group_id == DefaultGroupId.MEMBERS.value
assert user.groups_ids == [
admins_group.id,
moderators_group.id,
DefaultGroupId.MEMBERS.value,
]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_user_is_created_with_secondary_groups_ids(db, admins_group, moderators_group):
user = User.objects.create_user(
"User",
"test@example.com",
secondary_groups_ids=[admins_group.id, moderators_group.id],
)
assert user.group_id == DefaultGroupId.MEMBERS.value
assert user.groups_ids == [
admins_group.id,
moderators_group.id,
DefaultGroupId.MEMBERS.value,
]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_newly_created_user_last_login_is_same_as_join_date(db):
user = User.objects.create_user("User", "test@example.com")
assert user.last_login == user.joined_on
def test_user_is_created_with_authenticated_role(db):
user = User.objects.create_user("User", "test@example.com")
assert user.roles.get(special_role="authenticated")
def test_user_is_created_with_diacritics_in_email(db):
email = "łóć@łexąmple.com"
user = User.objects.create_user("UserName", email)
assert user.email == email
def test_creating_user_without_username_raises_value_error(db):
with pytest.raises(ValueError):
User.objects.create_user("", "test@example.com")
def test_creating_user_without_email_raises_value_error(db):
with pytest.raises(ValueError):
User.objects.create_user("User", "")
def test_creating_user_with_group_and_group_id_raises_value_error(
db, admins_group, moderators_group
):
with pytest.raises(ValueError):
User.objects.create_user(
"User",
"test@example.com",
group=admins_group,
group_id=moderators_group.id,
)
def test_creating_user_with_secondary_groups_and_secondary_groups_ids_raises_value_error(
db, admins_group, moderators_group
):
with pytest.raises(ValueError):
User.objects.create_user(
"User",
"test@example.com",
secondary_groups=[admins_group],
secondary_groups_ids=[moderators_group.id],
)
def test_creating_user_with_groups_id_raises_value_error(db):
with pytest.raises(ValueError):
User.objects.create_user(
"User",
"test@example.com",
groups_id=[1, 2, 3],
)
def test_creating_user_with_permissions_id_raises_value_error(db):
with pytest.raises(ValueError):
User.objects.create_user(
"User",
"test@example.com",
permissions_id="error",
)
def test_create_superuser(db):
user = User.objects.create_superuser("User", "test@example.com")
assert user.is_staff
assert user.is_superuser
assert user.is_misago_root
def test_superuser_is_created_with_team_rank(db):
user = User.objects.create_superuser("User", "test@example.com")
assert "team" in str(user.rank)
def test_superuser_is_created_with_admins_group(db, admins_group):
user = User.objects.create_superuser("User", "test@example.com")
assert user.group_id == admins_group.id
assert user.groups_ids == [admins_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_creating_superuser_without_staff_status_raises_value_error(db):
with pytest.raises(ValueError):
User.objects.create_superuser("User", "test@example.com", is_staff=False)
def test_creating_superuser_without_superuser_status_raises_value_error(db):
with pytest.raises(ValueError):
User.objects.create_superuser("User", "test@example.com", is_superuser=False)
| 7,469
|
Python
|
.py
| 166
| 39.078313
| 89
| 0.706866
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,467
|
test_update_group.py
|
rafalp_Misago/misago/users/tests/test_update_group.py
|
import pytest
from ..groups import update_group
def test_update_group_updates_group_attribute(custom_group):
update_group(custom_group, is_hidden=True)
assert custom_group.is_hidden
def test_update_group_updates_group_in_database(custom_group):
update_group(custom_group, name="Hello")
custom_group.refresh_from_db()
assert custom_group.name == "Hello"
def test_update_group_updates_slug_attribute_from_name(custom_group):
update_group(custom_group, name="New Name")
assert custom_group.slug == "new-name"
def test_update_group_updates_slug_attribute_separately_from_name(custom_group):
update_group(custom_group, name="New Name", slug="old-slug")
assert custom_group.slug == "old-slug"
def test_update_group_raises_type_error_for_invalid_attribute(custom_group):
with pytest.raises(TypeError):
update_group(custom_group, invalid_attr=True)
| 901
|
Python
|
.py
| 18
| 45.722222
| 80
| 0.760046
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,468
|
test_mention_api.py
|
rafalp_Misago/misago/users/tests/test_mention_api.py
|
from django.test import TestCase
from django.urls import reverse
from ..test import create_test_user
class AuthenticateApiTests(TestCase):
def setUp(self):
self.api_link = reverse("misago:api:mention-suggestions")
def test_no_query(self):
"""api returns empty result set if no query is given"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [])
def test_no_results(self):
"""api returns empty result set if no query is given"""
response = self.client.get(self.api_link + "?q=none")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [])
def test_user_search(self):
"""api searches uses"""
create_test_user("User", "user@example.com")
# exact case sensitive match
response = self.client.get(self.api_link + "?q=User")
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
[{"avatar": "http://dummyimage.com/100/100", "username": "User"}],
)
# case insensitive match
response = self.client.get(self.api_link + "?q=user")
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
[{"avatar": "http://dummyimage.com/100/100", "username": "User"}],
)
# eager case insensitive match
response = self.client.get(self.api_link + "?q=u")
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
[{"avatar": "http://dummyimage.com/100/100", "username": "User"}],
)
# invalid match
response = self.client.get(self.api_link + "?q=other")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), [])
| 1,916
|
Python
|
.py
| 44
| 34.818182
| 78
| 0.620968
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,469
|
test_realip_middleware.py
|
rafalp_Misago/misago/users/tests/test_realip_middleware.py
|
from django.http import HttpResponse
from ..middleware import RealIPMiddleware
def get_response(*_):
return HttpResponse("OK!")
class MockRequest:
def __init__(self, addr, forwarded_for=None):
self.META = {"REMOTE_ADDR": addr}
if forwarded_for:
self.META["HTTP_X_FORWARDED_FOR"] = forwarded_for
def test_user_ip_middleware_sets_ip_from_remote_add_on_request():
request = MockRequest("83.42.13.77")
RealIPMiddleware(get_response)(request)
assert request.user_ip == request.META["REMOTE_ADDR"]
def test_user_ip_middleware_sets_ip_from_forwarded_for_on_request():
request = MockRequest("127.0.0.1", "83.42.13.77")
RealIPMiddleware(get_response)(request)
assert request.user_ip == request.META["HTTP_X_FORWARDED_FOR"]
| 786
|
Python
|
.py
| 17
| 41
| 68
| 0.713342
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,470
|
test_create_group.py
|
rafalp_Misago/misago/users/tests/test_create_group.py
|
import pytest
from ..groups import create_group
from ..models import Group
def test_create_group_creates_new_group(db):
new_group = create_group(name="Top Users")
assert new_group.id
group_from_db = Group.objects.get(id=new_group.id)
assert group_from_db.name == "Top Users"
def test_create_group_sets_default__slug_from_name(db):
new_group = create_group(name="Top Users")
assert new_group.name == "Top Users"
assert new_group.slug == "top-users"
def test_create_group_sets_ordering(db):
new_group = create_group(name="Top Users")
assert new_group.ordering == 4
def test_create_group_saves_custom_plugin_data(db):
new_group = create_group(name="Top Users", plugin_data={"plugin": "ok"})
assert new_group.plugin_data == {"plugin": "ok"}
def test_create_group_accepts_request_kwarg(db):
new_group = create_group(name="Top Users", request=True)
assert new_group
def test_create_group_accepts_form_kwarg(db):
new_group = create_group(name="Top Users", request=True)
assert new_group
def test_create_group_raises_value_error_if_name_is_not_set(db):
with pytest.raises(ValueError):
create_group()
| 1,180
|
Python
|
.py
| 27
| 39.444444
| 76
| 0.718558
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,471
|
test_namechanges.py
|
rafalp_Misago/misago/users/tests/test_namechanges.py
|
from datetime import timedelta
from ..namechanges import get_left_namechanges, get_next_available_namechange
def test_user_without_permission_to_change_name_has_no_changes_left(user):
user_acl = {"name_changes_allowed": 0}
assert get_left_namechanges(user, user_acl) == 0
def test_user_without_namechanges_has_all_changes_left(user):
user_acl = {"name_changes_allowed": 3, "name_changes_expire": 0}
assert get_left_namechanges(user, user_acl) == 3
def test_user_own_namechanges_are_subtracted_from_changes_left(user):
user_acl = {"name_changes_allowed": 3, "name_changes_expire": 0}
user.set_username("Changed")
assert get_left_namechanges(user, user_acl) == 2
def test_user_own_recent_namechanges_subtract_from_changes_left(user):
user_acl = {"name_changes_allowed": 3, "name_changes_expire": 5}
user.set_username("Changed")
assert get_left_namechanges(user, user_acl) == 2
def test_user_own_expired_namechanges_dont_subtract_from_changes_left(user):
user_acl = {"name_changes_allowed": 3, "name_changes_expire": 5}
username_change = user.set_username("Changed")
username_change.changed_on -= timedelta(days=10)
username_change.save()
assert get_left_namechanges(user, user_acl) == 3
def test_user_namechanges_by_other_users_dont_subtract_from_changes_left(user):
user_acl = {"name_changes_allowed": 3, "name_changes_expire": 0}
username_change = user.set_username("Changed")
username_change.changed_by = None
username_change.save()
assert get_left_namechanges(user, user_acl) == 3
def test_user_next_available_namechange_is_none_for_user_with_changes_left(user):
user_acl = {"name_changes_allowed": 3, "name_changes_expire": 0}
assert get_next_available_namechange(user, user_acl, 3) is None
def test_user_next_available_namechange_is_none_if_own_namechanges_dont_expire(user):
user_acl = {"name_changes_allowed": 1, "name_changes_expire": 0}
user.set_username("Changed")
assert get_next_available_namechange(user, user_acl, 0) is None
def test_user_next_available_namechange_is_calculated_if_own_namechanges_expire(user):
user_acl = {"name_changes_allowed": 1, "name_changes_expire": 1}
username_change = user.set_username("Changed")
next_change_on = get_next_available_namechange(user, user_acl, 0)
assert next_change_on
assert next_change_on == username_change.changed_on + timedelta(days=1)
| 2,442
|
Python
|
.py
| 41
| 55.02439
| 86
| 0.734428
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,472
|
test_activation_views.py
|
rafalp_Misago/misago/users/tests/test_activation_views.py
|
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...core.utils import encode_json_html
from ..models import Ban
from ..test import create_test_user
from ..tokens import make_activation_token
User = get_user_model()
class ActivationViewsTests(TestCase):
def test_request_view_returns_200(self):
"""request new activation link view returns 200"""
response = self.client.get(reverse("misago:request-activation"))
self.assertEqual(response.status_code, 200)
def test_view_activate_banned(self):
"""activate banned user shows error"""
user = create_test_user("User", "user@example.com", requires_activation=1)
activation_token = make_activation_token(user)
Ban.objects.create(
check_type=Ban.USERNAME, banned_value="user", user_message="Nope!"
)
response = self.client.get(
reverse(
"misago:activate-by-token",
kwargs={"pk": user.pk, "token": activation_token},
)
)
self.assertContains(response, encode_json_html("<p>Nope!</p>"), status_code=403)
user = User.objects.get(pk=user.pk)
self.assertEqual(user.requires_activation, 1)
def test_view_activate_invalid_token(self):
"""activate with invalid token shows error"""
user = create_test_user("User", "user@example.com", requires_activation=1)
activation_token = make_activation_token(user)
response = self.client.get(
reverse(
"misago:activate-by-token",
kwargs={"pk": user.pk, "token": activation_token + "acd"},
)
)
self.assertEqual(response.status_code, 400)
user = User.objects.get(pk=user.pk)
self.assertEqual(user.requires_activation, 1)
def test_view_activate_disabled(self):
"""activate disabled user shows error"""
user = create_test_user("User", "user@example.com", is_active=False)
activation_token = make_activation_token(user)
response = self.client.get(
reverse(
"misago:activate-by-token",
kwargs={"pk": user.pk, "token": activation_token},
)
)
self.assertEqual(response.status_code, 404)
def test_view_activate_active(self):
"""activate active user shows error"""
user = create_test_user("User", "user@example.com")
activation_token = make_activation_token(user)
response = self.client.get(
reverse(
"misago:activate-by-token",
kwargs={"pk": user.pk, "token": activation_token},
)
)
self.assertEqual(response.status_code, 200)
user = User.objects.get(pk=user.pk)
self.assertEqual(user.requires_activation, 0)
def test_view_activate_inactive(self):
"""activate inactive user passess"""
user = create_test_user("User", "user@example.com", requires_activation=1)
activation_token = make_activation_token(user)
response = self.client.get(
reverse(
"misago:activate-by-token",
kwargs={"pk": user.pk, "token": activation_token},
)
)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "your account has been activated!")
user = User.objects.get(pk=user.pk)
self.assertEqual(user.requires_activation, 0)
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_request_activatiom_view_returns_403_if_oauth_is_enabled(db, client):
response = client.get(reverse("misago:request-activation"))
assert response.status_code == 403
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_activate_with_token_view_returns_403_if_oauth_is_enabled(db, client):
user = create_test_user("User", "user@example.com", requires_activation=1)
activation_token = make_activation_token(user)
response = client.post(
reverse(
"misago:activate-by-token",
kwargs={"pk": user.pk, "token": activation_token},
)
)
assert response.status_code == 403
| 4,365
|
Python
|
.py
| 102
| 34.186275
| 88
| 0.641661
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,473
|
test_createsuperuser.py
|
rafalp_Misago/misago/users/tests/test_createsuperuser.py
|
from io import StringIO
from django.contrib.auth import get_user_model
from django.core.management import call_command
User = get_user_model()
def test_superuser_is_created_if_input_is_valid(db):
out = StringIO()
call_command(
"createsuperuser",
interactive=False,
username="test",
email="test@example.com",
password="password",
stdout=out,
)
command_output = out.getvalue().splitlines()[-1].strip()
user = User.objects.order_by("-id")[:1][0]
assert command_output == ("Superuser #%s has been created successfully." % user.pk)
assert user.username == "test"
assert user.email == "test@example.com"
assert user.check_password("password")
| 729
|
Python
|
.py
| 20
| 30.85
| 87
| 0.677603
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,474
|
test_set_default_group.py
|
rafalp_Misago/misago/users/tests/test_set_default_group.py
|
from ..groups import set_default_group
def test_default_group_is_changed(members_group, custom_group):
assert members_group.is_default
assert not custom_group.is_default
set_default_group(custom_group)
custom_group.refresh_from_db()
assert custom_group.is_default
members_group.refresh_from_db()
assert not members_group.is_default
| 365
|
Python
|
.py
| 9
| 35.888889
| 63
| 0.766382
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,475
|
test_stop_forum_spam_validator.py
|
rafalp_Misago/misago/users/tests/test_stop_forum_spam_validator.py
|
import json
from unittest.mock import Mock
import pytest
from django.forms import ValidationError
from requests.exceptions import Timeout
from ...conf.test import override_dynamic_settings
from ..validators import validate_with_sfs
cleaned_data = {"email": "test@test.com"}
@pytest.fixture
def request_mock(dynamic_settings):
return Mock(settings=dynamic_settings, user_ip="127.0.0.1")
@pytest.fixture
def api_mock(mocker):
return mocker.patch(
"misago.users.validators.requests",
get=Mock(
return_value=Mock(
content=json.dumps(
{"email": {"confidence": 55}, "ip": {"confidence": 45}}
)
)
),
)
@override_dynamic_settings(enable_stop_forum_spam=False)
def test_api_is_not_called_if_sfs_is_disabled(api_mock, request_mock):
validate_with_sfs(request_mock, cleaned_data, None)
api_mock.get.assert_not_called()
@override_dynamic_settings(enable_stop_forum_spam=True)
def test_api_is_not_called_if_email_is_not_available(api_mock, request_mock):
validate_with_sfs(request_mock, {}, None)
api_mock.get.assert_not_called()
@override_dynamic_settings(enable_stop_forum_spam=True, stop_forum_spam_confidence=90)
def test_api_is_called_if_sfs_is_enabled_and_email_is_provided(api_mock, request_mock):
validate_with_sfs(request_mock, cleaned_data, None)
api_mock.get.assert_called_once()
@override_dynamic_settings(enable_stop_forum_spam=True, stop_forum_spam_confidence=50)
def test_validator_raises_error_if_ip_score_is_greater_than_confidence(
api_mock, request_mock
):
with pytest.raises(ValidationError):
validate_with_sfs(request_mock, cleaned_data, None)
@override_dynamic_settings(enable_stop_forum_spam=True, stop_forum_spam_confidence=52)
def test_validator_raises_error_if_email_score_is_greater_than_confidence(
api_mock, request_mock
):
with pytest.raises(ValidationError):
validate_with_sfs(request_mock, cleaned_data, None)
@override_dynamic_settings(enable_stop_forum_spam=True)
def test_validator_handles_api_error(mocker, request_mock):
failing_api_mock = mocker.patch(
"misago.users.validators.requests",
get=Mock(return_value=Mock(raise_for_status=Mock(side_effect=Timeout()))),
)
validate_with_sfs(request_mock, cleaned_data, None)
failing_api_mock.get.assert_called_once()
@override_dynamic_settings(enable_stop_forum_spam=True)
def test_validator_logs_api_error(mocker, request_mock):
failing_api_mock = mocker.patch(
"misago.users.validators.requests",
get=Mock(return_value=Mock(raise_for_status=Mock(side_effect=Timeout()))),
)
logger_mock = mocker.patch("misago.users.validators.logger", exception=Mock())
validate_with_sfs(request_mock, cleaned_data, None)
failing_api_mock.get.assert_called_once()
logger_mock.exception.assert_called_once()
@override_dynamic_settings(enable_stop_forum_spam=True)
def test_validator_handles_malformed_api_response(mocker, request_mock):
failing_api_mock = mocker.patch(
"misago.users.validators.requests", get=Mock(return_value=Mock(content="{}"))
)
validate_with_sfs(request_mock, cleaned_data, None)
failing_api_mock.get.assert_called_once()
| 3,286
|
Python
|
.py
| 72
| 40.611111
| 87
| 0.735257
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,476
|
test_ban_model.py
|
rafalp_Misago/misago/users/tests/test_ban_model.py
|
from django.test import TestCase
from ..models import Ban
class BansManagerTests(TestCase):
def setUp(self):
Ban.objects.bulk_create(
[
Ban(check_type=Ban.USERNAME, banned_value="user"),
Ban(check_type=Ban.EMAIL, banned_value="user@example.com"),
Ban(check_type=Ban.IP, banned_value="127.0.0.1"),
]
)
def test_get_ban_for_banned_name(self):
"""get_ban finds ban for given username"""
self.assertIsNotNone(Ban.objects.get_ban(username="User"))
with self.assertRaises(Ban.DoesNotExist):
Ban.objects.get_ban(username="Other_User")
def test_get_ban_for_banned_email(self):
"""get_ban finds ban for given email"""
self.assertIsNotNone(Ban.objects.get_ban(email="user@example.com"))
with self.assertRaises(Ban.DoesNotExist):
Ban.objects.get_ban(email="otheruser@example.com")
def test_get_ban_for_banned_ip(self):
"""get_ban finds ban for given ip"""
self.assertIsNotNone(Ban.objects.get_ban(ip="127.0.0.1"))
with self.assertRaises(Ban.DoesNotExist):
Ban.objects.get_ban(ip="42.0.0.1")
def test_get_ban_for_all_values(self):
"""get_ban finds ban for given values"""
valid_kwargs = {"username": "User", "ip": "42.51.52.51"}
self.assertIsNotNone(Ban.objects.get_ban(**valid_kwargs))
invalid_kwargs = {"username": "Other_User", "ip": "42.51.52.51"}
with self.assertRaises(Ban.DoesNotExist):
Ban.objects.get_ban(**invalid_kwargs)
class BanTests(TestCase):
def test_check_value_literal(self):
"""ban correctly tests given values"""
test_ban = Ban(banned_value="user")
self.assertTrue(test_ban.check_value("User"))
self.assertFalse(test_ban.check_value("Other_User"))
self.assertFalse(test_ban.check_value("UserOther"))
def test_check_value_starts_with(self):
"""ban correctly tests given values"""
test_ban = Ban(banned_value="user*")
self.assertTrue(test_ban.check_value("User"))
self.assertTrue(test_ban.check_value("UserOther"))
self.assertFalse(test_ban.check_value("NewUser"))
def test_check_value_middle_match(self):
"""ban correctly tests given values"""
test_ban = Ban(banned_value="u*r")
self.assertTrue(test_ban.check_value("User"))
self.assertTrue(test_ban.check_value("UserOther"))
self.assertFalse(test_ban.check_value("NewUser"))
self.assertFalse(test_ban.check_value("UserNew"))
def test_check_value_ends_witch(self):
"""ban correctly tests given values"""
test_ban = Ban(banned_value="*user")
self.assertTrue(test_ban.check_value("User"))
self.assertTrue(test_ban.check_value("Other_User"))
self.assertFalse(test_ban.check_value("UserOther"))
| 2,917
|
Python
|
.py
| 59
| 40.491525
| 75
| 0.644843
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,477
|
test_credentialchange.py
|
rafalp_Misago/misago/users/tests/test_credentialchange.py
|
from django.test import TestCase
from ...users import credentialchange
from ..test import create_test_user
class MockRequest:
def __init__(self, user):
self.session = {}
self.user = user
class CredentialChangeTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com")
def test_valid_token_generation(self):
"""credentialchange module allows for store and read of change token"""
request = MockRequest(self.user)
token = credentialchange.store_new_credential(
request, "email", "newmail@example.com"
)
email = credentialchange.read_new_credential(request, "email", token)
self.assertEqual(email, "newmail@example.com")
def test_email_change_invalidated_token(self):
"""token is invalidated by email change"""
request = MockRequest(self.user)
token = credentialchange.store_new_credential(
request, "email", "newmail@example.com"
)
self.user.set_email("otheremail@example.com")
self.user.save()
email = credentialchange.read_new_credential(request, "email", token)
self.assertIsNone(email)
def test_password_change_invalidated_token(self):
"""token is invalidated by password change"""
request = MockRequest(self.user)
token = credentialchange.store_new_credential(
request, "email", "newmail@example.com"
)
self.user.set_password("Egebeg!123")
self.user.save()
email = credentialchange.read_new_credential(request, "email", token)
self.assertIsNone(email)
def test_invalid_token_is_handled(self):
"""there are no explosions in invalid tokens handling"""
request = MockRequest(self.user)
token = credentialchange.store_new_credential(
request, "email", "newmail@example.com"
)
email = credentialchange.read_new_credential(request, "em4il", token)
self.assertIsNone(email)
| 2,037
|
Python
|
.py
| 46
| 36
| 79
| 0.666498
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,478
|
test_deleteprofilefield.py
|
rafalp_Misago/misago/users/tests/test_deleteprofilefield.py
|
from io import StringIO
from django.core.management import call_command
from django.test import TestCase
from ..management.commands import deleteprofilefield
from ..test import create_test_user
class DeleteProfileFieldTests(TestCase):
def test_no_fieldname(self):
"""utility has no showstoppers when no fieldname is given"""
out = StringIO()
call_command(deleteprofilefield.Command(), stderr=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Specify fieldname to delete.")
def test_no_fields_set(self):
"""utility has no showstoppers when no fields are set"""
out = StringIO()
call_command(deleteprofilefield.Command(), "gender", stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(
command_output, '"gender" profile field has been deleted from 0 users.'
)
def test_delete_fields(self):
"""utility has no showstoppers when no fields are set"""
user = create_test_user(
"User", "user@example.com", profile_fields={"gender": "male", "bio": "Yup!"}
)
out = StringIO()
call_command(deleteprofilefield.Command(), "gender", stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(
command_output, '"gender" profile field has been deleted from 1 users.'
)
user.refresh_from_db()
self.assertEqual(user.profile_fields, {"bio": "Yup!"})
| 1,561
|
Python
|
.py
| 33
| 39.424242
| 88
| 0.664469
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,479
|
test_datadownloads.py
|
rafalp_Misago/misago/users/tests/test_datadownloads.py
|
import os
from datetime import timedelta
from django.core.files import File
from django.utils import timezone
from ...categories.models import Category
from ...notifications.models import Notification
from ...threads.models import AttachmentType
from ...threads.test import post_poll, post_thread
from ..audittrail import create_user_audit_trail
from ..datadownloads import (
expire_user_data_download,
prepare_user_data_download,
request_user_data_download,
user_has_data_download_request,
)
from ..models import DataDownload
from ..test import AuthenticatedUserTestCase
EXPIRATION = 4
TESTFILES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "testfiles")
TEST_FILE_PATH = os.path.join(TESTFILES_DIR, "avatar.png")
class ExpireUserDataDownloadTests(AuthenticatedUserTestCase):
def test_util_marks_download_as_expired(self):
"""expire_user_data_download changed data download status to expired"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_READY
with open(TEST_FILE_PATH, "rb") as download_file:
data_download.file = File(download_file)
data_download.save()
expire_user_data_download(data_download)
self.assertEqual(data_download.status, DataDownload.STATUS_EXPIRED)
def test_util_deletes_file(self):
"""expire_user_data_download deleted file associated with download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_READY
with open(TEST_FILE_PATH, "rb") as download_file:
data_download.file = File(download_file)
data_download.save()
download_file_path = data_download.file.path
expire_user_data_download(data_download)
self.assertFalse(data_download.file)
self.assertFalse(os.path.isdir(download_file_path))
def test_util_expires_download_without_file(self):
"""expire_user_data_download handles missing download file"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_READY
expire_user_data_download(data_download)
self.assertEqual(data_download.status, DataDownload.STATUS_EXPIRED)
class PrepareUserDataDownload(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.download = request_user_data_download(self.user)
def assert_download_is_valid(self):
result = prepare_user_data_download(self.download, EXPIRATION)
self.assertTrue(result)
self.download.refresh_from_db()
self.assertTrue(self.download.file)
def test_prepare_basic_download(self):
"""function creates data download for basic user account"""
self.assert_download_is_valid()
def test_data_download_is_prepared_with_expiration_date(self):
"""function creates data download with specified expiration date"""
expires_on = timezone.now() + timedelta(hours=EXPIRATION)
prepare_user_data_download(self.download, EXPIRATION)
self.download.refresh_from_db
self.assertGreater(self.download.expires_on, expires_on)
def test_prepare_download_with_profle_fields(self):
"""function creates data download for user with profile fields"""
self.user.profile_fields = {"real_name": "Bob Boberthon!"}
self.user.save()
self.assert_download_is_valid()
def test_prepare_download_with_tmp_avatar(self):
"""function creates data download for user with tmp avatar"""
with open(TEST_FILE_PATH, "rb") as test_file:
self.user.avatar_tmp = File(test_file)
self.user.save()
self.assert_download_is_valid()
def test_prepare_download_with_src_avatar(self):
"""function creates data download for user with src avatar"""
with open(TEST_FILE_PATH, "rb") as test_file:
self.user.avatar_src = File(test_file)
self.user.save()
self.assert_download_is_valid()
def test_prepare_download_with_avatar_set(self):
"""function creates data download for user with avatar set"""
with open(TEST_FILE_PATH, "rb") as test_file:
self.user.avatar_set.create(size=100, image=File(test_file))
self.assert_download_is_valid()
def test_prepare_download_with_file_attachment(self):
"""function creates data download for user with file attachment"""
filetype = AttachmentType.objects.create(
name="Test extension", extensions="png", mimetypes="image/png"
)
with open(TEST_FILE_PATH, "rb") as test_file:
self.user.attachment_set.create(
secret="test",
filetype=filetype,
uploader_name=self.user.username,
uploader_slug=self.user.slug,
filename="test.png",
size=1000,
file=File(test_file),
)
self.assert_download_is_valid()
def test_prepare_download_with_image_attachment(self):
"""function creates data download for user with image attachment"""
filetype = AttachmentType.objects.create(
name="Test extension", extensions="png", mimetypes="image/png"
)
with open(TEST_FILE_PATH, "rb") as test_file:
self.user.attachment_set.create(
secret="test",
filetype=filetype,
uploader_name=self.user.username,
uploader_slug=self.user.slug,
filename="test.png",
size=1000,
image=File(test_file),
)
self.assert_download_is_valid()
def test_prepare_download_with_thumbnail_attachment(self):
"""function creates data download for user with thumbnail attachment"""
filetype = AttachmentType.objects.create(
name="Test extension", extensions="png", mimetypes="image/png"
)
with open(TEST_FILE_PATH, "rb") as test_file:
self.user.attachment_set.create(
secret="test",
filetype=filetype,
uploader_name=self.user.username,
uploader_slug=self.user.slug,
filename="test.png",
size=1000,
thumbnail=File(test_file),
)
self.assert_download_is_valid()
def test_prepare_download_with_self_username_change(self):
"""function creates data download for user that changed their username"""
self.user.record_name_change(self.user, "aerith", "alice")
self.assert_download_is_valid()
def test_prepare_download_with_username_changed_by_staff(self):
"""function creates data download for user with username changed by staff"""
staff_user = self.get_superuser()
self.user.record_name_change(staff_user, "aerith", "alice")
self.assert_download_is_valid()
def test_prepare_download_with_username_changed_by_deleted_user(self):
"""
function creates data download for user with username changed by deleted user
"""
self.user.record_name_change(self.user, "aerith", "alice")
self.user.namechanges.update(changed_by=None)
self.assert_download_is_valid()
def test_prepare_download_with_audit_trail(self):
"""function creates data download for user with audit trail"""
create_user_audit_trail(self.user, "127.0.0.1", self.user)
self.assert_download_is_valid()
def test_prepare_download_notification(self):
"""function creates data download for user with notification"""
Notification.objects.create(user=self.user, verb="TEST")
self.assert_download_is_valid()
def test_prepare_download_with_post(self):
"""function creates data download for user with post"""
category = Category.objects.get(slug="first-category")
post_thread(category, poster=self.user)
self.assert_download_is_valid()
def test_prepare_download_with_owm_post_edit(self):
"""function creates data download for user with own post edit"""
category = Category.objects.get(slug="first-category")
thread = post_thread(category, poster=self.user)
post = thread.first_post
post.edits_record.create(
category=category,
thread=thread,
editor=self.user,
editor_name=self.user.username,
editor_slug=self.user.slug,
edited_from="edited from",
edited_to="edited to",
)
self.assert_download_is_valid()
def test_prepare_download_with_other_users_post_edit(self):
"""function creates data download for user with other user's post edit"""
category = Category.objects.get(slug="first-category")
thread = post_thread(category)
post = thread.first_post
post.edits_record.create(
category=category,
thread=thread,
editor=self.user,
editor_name=self.user.username,
editor_slug=self.user.slug,
edited_from="edited from",
edited_to="edited to",
)
self.assert_download_is_valid()
def test_prepare_download_with_own_post_edit_by_staff(self):
"""function creates data download for user with post edited by staff"""
category = Category.objects.get(slug="first-category")
thread = post_thread(category, poster=self.user)
post = thread.first_post
staff_user = self.get_superuser()
post.edits_record.create(
category=category,
thread=thread,
editor=staff_user,
editor_name=staff_user.username,
editor_slug=staff_user.slug,
edited_from="edited from",
edited_to="edited to",
)
self.assert_download_is_valid()
def test_prepare_download_with_poll(self):
"""function creates data download for user with poll"""
category = Category.objects.get(slug="first-category")
thread = post_thread(category, poster=self.user)
post_poll(thread, self.user)
self.assert_download_is_valid()
class RequestUserDataDownloadTests(AuthenticatedUserTestCase):
def test_util_creates_data_download_for_user_with_them_as_requester(self):
"""request_user_data_download created valid data download for user"""
data_download = request_user_data_download(self.user)
self.assertEqual(data_download.user, self.user)
self.assertEqual(data_download.requester, self.user)
self.assertEqual(data_download.requester_name, self.user.username)
self.assertEqual(data_download.status, DataDownload.STATUS_PENDING)
def test_util_creates_data_download_for_user_explicit_requester(self):
"""
request_user_data_download created valid data download
for user with other requester
"""
requester = self.get_superuser()
data_download = request_user_data_download(self.user, requester)
self.assertEqual(data_download.user, self.user)
self.assertEqual(data_download.requester, requester)
self.assertEqual(data_download.requester_name, requester.username)
self.assertEqual(data_download.status, DataDownload.STATUS_PENDING)
class UserHasRequestedDataDownloadTests(AuthenticatedUserTestCase):
def test_util_returns_false_for_no_download(self):
"""
user_has_data_download_request returns false if user has no requests in progress
"""
self.assertFalse(user_has_data_download_request(self.user))
def test_util_returns_false_for_ready_download(self):
"""user_has_data_download_request returns false if user has ready download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_READY
data_download.save()
self.assertFalse(user_has_data_download_request(self.user))
def test_util_returns_false_for_expired_download(self):
"""user_has_data_download_request returns false if user has expired download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_EXPIRED
data_download.save()
self.assertFalse(user_has_data_download_request(self.user))
def test_util_returns_true_for_pending_download(self):
"""user_has_data_download_request returns true if user has pending download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_PENDING
data_download.save()
self.assertTrue(user_has_data_download_request(self.user))
def test_util_returns_true_for_processing_download(self):
"""
user_has_data_download_request returns true if user has processing download
"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_PROCESSING
data_download.save()
self.assertTrue(user_has_data_download_request(self.user))
| 13,239
|
Python
|
.py
| 267
| 40.202247
| 88
| 0.672406
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,480
|
test_populate_online_tracker_command.py
|
rafalp_Misago/misago/users/tests/test_populate_online_tracker_command.py
|
from io import StringIO
from django.core.management import call_command
from ..management.commands import populateonlinetracker
from ..models import Online
def test_management_command_creates_online_tracker_for_user_without_one(user):
Online.objects.filter(user=user).delete()
assert not Online.objects.filter(user=user).exists()
call_command(populateonlinetracker.Command(), stdout=StringIO())
assert Online.objects.filter(user=user).exists()
def test_management_command_displays_message_with_number_of_created_trackers(user):
Online.objects.filter(user=user).delete()
assert not Online.objects.filter(user=user).exists()
out = StringIO()
call_command(populateonlinetracker.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
assert command_output == "Tracker entries created: 1"
| 856
|
Python
|
.py
| 16
| 49.5
| 83
| 0.780048
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,481
|
test_recording_deletes.py
|
rafalp_Misago/misago/users/tests/test_recording_deletes.py
|
from ..deletesrecord import (
record_user_deleted_by_self,
record_user_deleted_by_staff,
record_user_deleted_by_system,
)
from ..models import DeletedUser
def test_deletion_by_self_creates_record(db):
record_user_deleted_by_self()
DeletedUser.objects.get(deleted_by=DeletedUser.DELETED_BY_SELF)
def test_deletion_by_staff_creates_record(db):
record_user_deleted_by_staff()
DeletedUser.objects.get(deleted_by=DeletedUser.DELETED_BY_STAFF)
def test_deletion_by_system_creates_record(db):
record_user_deleted_by_system()
DeletedUser.objects.get(deleted_by=DeletedUser.DELETED_BY_SYSTEM)
| 626
|
Python
|
.py
| 15
| 37.933333
| 69
| 0.77686
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,482
|
test_usernamechanges_api.py
|
rafalp_Misago/misago/users/tests/test_usernamechanges_api.py
|
from ...acl.test import patch_user_acl
from ..test import AuthenticatedUserTestCase
class UsernameChangesApiTests(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.link = "/api/username-changes/"
@patch_user_acl({"can_see_users_name_history": False})
def test_user_can_always_see_his_name_changes(self):
"""list returns own username changes"""
self.user.set_username("NewUsername", self.user)
response = self.client.get("%s?user=%s" % (self.link, self.user.pk))
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.user.username)
@patch_user_acl({"can_see_users_name_history": True})
def test_list_handles_invalid_filter(self):
"""list raises 404 for invalid filter"""
self.user.set_username("NewUsername", self.user)
response = self.client.get("%s?user=abcd" % self.link)
self.assertEqual(response.status_code, 404)
@patch_user_acl({"can_see_users_name_history": True})
def test_list_handles_nonexisting_user(self):
"""list raises 404 for invalid user id"""
self.user.set_username("NewUsername", self.user)
response = self.client.get("%s?user=142141" % self.link)
self.assertEqual(response.status_code, 404)
@patch_user_acl({"can_see_users_name_history": False})
def test_list_handles_search(self):
"""list returns found username changes"""
self.user.set_username("NewUsername", self.user)
response = self.client.get("%s?user=%s&search=new" % (self.link, self.user.pk))
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.user.username)
response = self.client.get(
"%s?user=%s&search=usernew" % (self.link, self.user.pk)
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["count"], 0)
@patch_user_acl({"can_see_users_name_history": False})
def test_list_denies_permission(self):
"""list denies permission for other user (or all) if no access"""
response = self.client.get("%s?user=%s" % (self.link, self.user.pk + 1))
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "You don't have permission to see other users name history."},
)
response = self.client.get(self.link)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.json(),
{"detail": "You don't have permission to see other users name history."},
)
| 2,642
|
Python
|
.py
| 52
| 42.538462
| 87
| 0.655039
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,483
|
test_avatar_filter.py
|
rafalp_Misago/misago/users/tests/test_avatar_filter.py
|
import pytest
from ..templatetags.misago_avatars import avatar
@pytest.fixture
def avatars(user):
return {i["size"]: i["url"] for i in user.avatars}
def test_filter_returns_url_to_200_size_image(user, avatars):
assert avatar(user) == avatars[200]
def test_filter_returns_url_to_next_largest_image_for_given_size(user, avatars):
assert avatar(user, 250) == avatars[400]
assert avatar(user, 150) == avatars[200]
assert avatar(user, 50) == avatars[100]
def test_filter_returns_url_largest_image_if_requested_size_is_not_available(
user, avatars
):
assert avatar(user, 500) == avatars[400]
| 623
|
Python
|
.py
| 15
| 38.066667
| 80
| 0.734558
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,484
|
test_new_user_setup.py
|
rafalp_Misago/misago/users/tests/test_new_user_setup.py
|
from django.contrib.auth import get_user_model
from ...conf.test import override_dynamic_settings
from ...notifications.threads import ThreadNotifications
from ..setupnewuser import setup_new_user
User = get_user_model()
AVATAR_URL = "https://dummyimage.com/600/500"
def user(db):
return User.objects.create_user("User", "user@example.com")
def test_default_avatar_is_set_for_user(dynamic_settings, user):
setup_new_user(dynamic_settings, user)
assert user.avatars
assert user.avatar_set.exists()
def test_avatar_from_url_is_set_for_user(dynamic_settings, user):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.avatars
assert user.avatar_set.exists()
def test_default_started_threads_subscription_option_is_set_for_user(
dynamic_settings, user
):
with override_dynamic_settings(subscribe_start="no"):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.subscribe_to_started_threads == User.SUBSCRIPTION_NONE
with override_dynamic_settings(subscribe_start="watch"):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.subscribe_to_started_threads == User.SUBSCRIPTION_NOTIFY
with override_dynamic_settings(subscribe_start="watch_email"):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.subscribe_to_started_threads == User.SUBSCRIPTION_ALL
def test_default_replied_threads_subscription_option_is_set_for_user(
dynamic_settings, user
):
with override_dynamic_settings(subscribe_reply="no"):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.subscribe_to_replied_threads == User.SUBSCRIPTION_NONE
with override_dynamic_settings(subscribe_reply="watch"):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.subscribe_to_replied_threads == User.SUBSCRIPTION_NOTIFY
with override_dynamic_settings(subscribe_reply="watch_email"):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.subscribe_to_replied_threads == User.SUBSCRIPTION_ALL
def test_default_watch_started_threads_option_is_set_for_user(dynamic_settings, user):
with override_dynamic_settings(watch_started_threads=ThreadNotifications.NONE):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_started_threads == ThreadNotifications.NONE
with override_dynamic_settings(watch_started_threads=ThreadNotifications.SITE_ONLY):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_started_threads == ThreadNotifications.SITE_ONLY
with override_dynamic_settings(
watch_started_threads=ThreadNotifications.SITE_AND_EMAIL
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_started_threads == ThreadNotifications.SITE_AND_EMAIL
def test_default_watch_replied_threads_option_is_set_for_user(dynamic_settings, user):
with override_dynamic_settings(watch_replied_threads=ThreadNotifications.NONE):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_replied_threads == ThreadNotifications.NONE
with override_dynamic_settings(watch_replied_threads=ThreadNotifications.SITE_ONLY):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_replied_threads == ThreadNotifications.SITE_ONLY
with override_dynamic_settings(
watch_replied_threads=ThreadNotifications.SITE_AND_EMAIL
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_replied_threads == ThreadNotifications.SITE_AND_EMAIL
def test_default_watch_new_private_threads_by_followed_option_is_set_for_user(
dynamic_settings, user
):
with override_dynamic_settings(
watch_new_private_threads_by_followed=ThreadNotifications.NONE
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_new_private_threads_by_followed == ThreadNotifications.NONE
with override_dynamic_settings(
watch_new_private_threads_by_followed=ThreadNotifications.SITE_ONLY
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.watch_new_private_threads_by_followed == ThreadNotifications.SITE_ONLY
)
with override_dynamic_settings(
watch_new_private_threads_by_followed=ThreadNotifications.SITE_AND_EMAIL
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.watch_new_private_threads_by_followed
== ThreadNotifications.SITE_AND_EMAIL
)
def test_default_watch_new_private_threads_by_other_users_option_is_set_for_user(
dynamic_settings, user
):
with override_dynamic_settings(
watch_new_private_threads_by_other_users=ThreadNotifications.NONE
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.watch_new_private_threads_by_other_users == ThreadNotifications.NONE
with override_dynamic_settings(
watch_new_private_threads_by_other_users=ThreadNotifications.SITE_ONLY
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.watch_new_private_threads_by_other_users
== ThreadNotifications.SITE_ONLY
)
with override_dynamic_settings(
watch_new_private_threads_by_other_users=ThreadNotifications.SITE_AND_EMAIL
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.watch_new_private_threads_by_other_users
== ThreadNotifications.SITE_AND_EMAIL
)
def test_default_notify_new_private_threads_by_followed_option_is_set_for_user(
dynamic_settings, user
):
with override_dynamic_settings(
notify_new_private_threads_by_followed=ThreadNotifications.NONE
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert user.notify_new_private_threads_by_followed == ThreadNotifications.NONE
with override_dynamic_settings(
notify_new_private_threads_by_followed=ThreadNotifications.SITE_ONLY
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.notify_new_private_threads_by_followed == ThreadNotifications.SITE_ONLY
)
with override_dynamic_settings(
notify_new_private_threads_by_followed=ThreadNotifications.SITE_AND_EMAIL
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.notify_new_private_threads_by_followed
== ThreadNotifications.SITE_AND_EMAIL
)
def test_default_notify_new_private_threads_by_other_users_option_is_set_for_user(
dynamic_settings, user
):
with override_dynamic_settings(
notify_new_private_threads_by_other_users=ThreadNotifications.NONE
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.notify_new_private_threads_by_other_users == ThreadNotifications.NONE
)
with override_dynamic_settings(
notify_new_private_threads_by_other_users=ThreadNotifications.SITE_ONLY
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.notify_new_private_threads_by_other_users
== ThreadNotifications.SITE_ONLY
)
with override_dynamic_settings(
notify_new_private_threads_by_other_users=ThreadNotifications.SITE_AND_EMAIL
):
setup_new_user(dynamic_settings, user, avatar_url=AVATAR_URL)
assert (
user.notify_new_private_threads_by_other_users
== ThreadNotifications.SITE_AND_EMAIL
)
def test_if_user_ip_is_available_audit_trail_is_created_for_user(dynamic_settings):
user = User.objects.create_user(
"User", "user@example.com", joined_from_ip="0.0.0.0"
)
setup_new_user(dynamic_settings, user)
assert user.audittrail_set.count() == 1
def test_if_user_ip_is_not_available_audit_trail_is_not_created(dynamic_settings, user):
setup_new_user(dynamic_settings, user)
assert user.audittrail_set.exists() is False
| 8,396
|
Python
|
.py
| 169
| 42.591716
| 88
| 0.726595
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,485
|
test_validators.py
|
rafalp_Misago/misago/users/tests/test_validators.py
|
from unittest.mock import Mock
from django.core.exceptions import ValidationError
from django.test import TestCase
from ..models import Ban
from ..test import create_test_user
from ..validators import (
validate_email,
validate_email_available,
validate_email_banned,
validate_gmail_email,
validate_username,
validate_username_available,
validate_username_banned,
validate_username_content,
validate_username_length,
)
class ValidateEmailAvailableTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com")
def test_valid_email(self):
"""validate_email_available allows available emails"""
validate_email_available("other@example.com")
validate_email_available(self.user.email, exclude=self.user)
def test_invalid_email(self):
"""validate_email_available disallows unvailable emails"""
with self.assertRaises(ValidationError):
validate_email_available(self.user.email)
class ValidateEmailBannedTests(TestCase):
def setUp(self):
Ban.objects.create(check_type=Ban.EMAIL, banned_value="ban@test.com")
def test_unbanned_name(self):
"""unbanned email passes validation"""
validate_email_banned("noban@test.com")
def test_banned_name(self):
"""banned email fails validation"""
with self.assertRaises(ValidationError):
validate_email_banned("ban@test.com")
class ValidateEmailTests(TestCase):
def test_validate_email(self):
"""validate_email has no crashes"""
validate_email("user@example.com")
with self.assertRaises(ValidationError):
validate_email("*")
class ValidateUsernameTests(TestCase):
def test_validate_username(self):
"""validate_username has no crashes"""
settings = Mock(username_length_min=1, username_length_max=5)
validate_username(settings, "LeBob")
validate_username(settings, "123")
validate_username(settings, "LeB_b")
validate_username(settings, "_a_")
validate_username(settings, "_123_")
with self.assertRaises(ValidationError):
validate_username(settings, "*")
with self.assertRaises(ValidationError):
validate_username(settings, "___")
class ValidateUsernameAvailableTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com")
def test_valid_name(self):
"""validate_username_available allows available names"""
validate_username_available("Other_User")
validate_username_available(self.user.username, exclude=self.user)
def test_invalid_name(self):
"""validate_username_available disallows unvailable names"""
with self.assertRaises(ValidationError):
validate_username_available(self.user.username)
class ValidateUsernameBannedTests(TestCase):
def setUp(self):
Ban.objects.create(check_type=Ban.USERNAME, banned_value="Ban")
def test_unbanned_name(self):
"""unbanned name passes validation"""
validate_username_banned("User")
def test_banned_name(self):
"""banned name fails validation"""
with self.assertRaises(ValidationError):
validate_username_banned("Ban")
class ValidateUsernameContentTests(TestCase):
def test_valid_name(self):
"""validate_username_content allows valid names"""
validate_username_content("123")
validate_username_content("User")
validate_username_content("User123")
def test_invalid_name(self):
"""validate_username_content disallows invalid names"""
with self.assertRaises(ValidationError):
validate_username_content("!")
with self.assertRaises(ValidationError):
validate_username_content("User!")
with self.assertRaises(ValidationError):
validate_username_content("John Doe")
with self.assertRaises(ValidationError):
validate_username_content("Rafał")
with self.assertRaises(ValidationError):
validate_username_content("初音 ミク")
class ValidateUsernameLengthTests(TestCase):
def test_valid_name(self):
"""validate_username_length allows valid names"""
settings = Mock(username_length_min=1, username_length_max=5)
validate_username_length(settings, "a" * settings.username_length_min)
validate_username_length(settings, "a" * settings.username_length_max)
def test_invalid_name(self):
"""validate_username_length disallows invalid names"""
settings = Mock(username_length_min=1, username_length_max=5)
with self.assertRaises(ValidationError):
validate_username_length(settings, "a" * (settings.username_length_min - 1))
with self.assertRaises(ValidationError):
validate_username_length(settings, "a" * (settings.username_length_max + 1))
class ValidateGmailEmailTests(TestCase):
def test_validate_gmail_email(self):
"""validate_gmail_email spots spammy gmail address"""
added_errors = {}
def add_errors(field_name, errors):
added_errors[field_name] = errors
validate_gmail_email(None, {}, add_errors)
validate_gmail_email(None, {"email": "invalid-email"}, add_errors)
validate_gmail_email(None, {"email": "the.valid.email@gmail.com"}, add_errors)
validate_gmail_email(None, {"email": "the.valid.email@hotmail.com"}, add_errors)
self.assertFalse(added_errors)
validate_gmail_email(
None, {"email": "the.s.p.a.m.my.e.ma.il@gmail.com"}, add_errors
)
self.assertTrue(added_errors)
| 5,732
|
Python
|
.py
| 123
| 38.682927
| 88
| 0.690262
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,486
|
test_twitter_profilefield.py
|
rafalp_Misago/misago/users/tests/test_twitter_profilefield.py
|
from django.contrib.auth import get_user_model
from django.urls import reverse
from ...admin.test import AdminTestCase
User = get_user_model()
class TwitterProfileFieldTests(AdminTestCase):
def setUp(self):
super().setUp()
self.test_link = reverse("misago:admin:users:edit", kwargs={"pk": self.user.pk})
def test_field_displays_in_admin(self):
"""field displays in admin"""
response = self.client.get(self.test_link)
self.assertContains(response, 'name="twitter"')
def test_admin_clears_field(self):
"""admin form allows admins to clear field"""
self.user.profile_fields["twitter"] = "lorem_ipsum"
self.user.save()
self.reload_user()
self.assertEqual(self.user.profile_fields["twitter"], "lorem_ipsum")
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertEqual(response.status_code, 302)
self.reload_user()
self.assertEqual(self.user.profile_fields["twitter"], "")
def test_admin_validates_field(self):
"""admin form allows admins to edit field"""
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"twitter": "lorem!ipsum",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertContains(response, "This is not a valid X handle.")
def test_admin_edits_field(self):
"""admin form allows admins to edit field"""
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"twitter": "lorem_ipsum",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertEqual(response.status_code, 302)
self.reload_user()
self.assertEqual(self.user.profile_fields["twitter"], "lorem_ipsum")
def test_admin_search_field(self):
"""admin users search searches this field"""
test_link = reverse("misago:admin:users:index")
response = self.client.get("%s?redirected=1&profilefields=ipsum" % test_link)
self.assertContains(response, "No users matching criteria exist.")
self.user.profile_fields["twitter"] = "lorem_ipsum"
self.user.save()
response = self.client.get("%s?redirected=1&profilefields=ipsum" % test_link)
self.assertNotContains(response, "No users matching criteria exist.")
def test_field_display(self):
"""field displays on user profile when filled in"""
test_link = reverse(
"misago:user-details", kwargs={"pk": self.user.pk, "slug": self.user.slug}
)
response = self.client.get(test_link)
self.assertNotContains(response, "Twitter")
self.user.profile_fields["twitter"] = "lorem_ipsum"
self.user.save()
response = self.client.get(test_link)
self.assertContains(response, "Twitter")
self.assertContains(response, 'href="https://twitter.com/lorem_ipsum"')
self.assertContains(response, "@lorem_ipsum")
def test_field_display_json(self):
"""field is included in display json"""
test_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
}
],
)
self.user.profile_fields["twitter"] = "lorem_ipsum"
self.user.save()
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "Contact",
"fields": [
{
"fieldname": "twitter",
"name": "X (formerly Twitter) handle",
"text": "@lorem_ipsum",
"url": "https://twitter.com/lorem_ipsum",
}
],
},
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
},
],
)
def test_api_returns_field_json(self):
"""field json is returned from API"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
found_field = None
for group in response.json():
for field in group["fields"]:
if field["fieldname"] == "twitter":
found_field = field
self.assertEqual(
found_field,
{
"fieldname": "twitter",
"label": "X (formerly Twitter) handle",
"help_text": (
"If you own an X account, here you may enter your X "
'handle for other users to find you. Starting your handle with "@" '
'sign is optional. Either "@testsuperuser" or "testsuperuser" are '
"valid values."
),
"input": {"type": "text"},
"initial": "",
},
)
def test_api_clears_field(self):
"""field can be cleared via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
self.user.profile_fields["twitter"] = "lorem_ipsum"
self.user.save()
self.reload_user()
self.assertEqual(self.user.profile_fields["twitter"], "lorem_ipsum")
response = self.client.post(test_link, data={})
self.assertEqual(response.status_code, 200)
self.reload_user()
self.assertEqual(self.user.profile_fields["twitter"], "")
def test_api_validates_field(self):
"""field can be edited via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.post(test_link, data={"twitter": "@lorem!ipsum"})
self.assertContains(response, "This is not a valid X handle.", status_code=400)
def test_api_edits_field(self):
"""field can be edited via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.post(test_link, data={"twitter": "@lorem_ipsum"})
self.assertEqual(response.status_code, 200)
self.reload_user()
self.assertEqual(self.user.profile_fields["twitter"], "lorem_ipsum")
| 9,868
|
Python
|
.py
| 218
| 31.825688
| 88
| 0.524037
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,487
|
test_avatarserver_views.py
|
rafalp_Misago/misago/users/tests/test_avatarserver_views.py
|
from django.test import TestCase
from django.urls import reverse
from ...conf import settings
from ..test import create_test_user
class AvatarServerTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "User@example.com")
def test_get_user_avatar_exact_size(self):
"""avatar server resolved valid avatar url for user"""
avatar_url = reverse(
"misago:user-avatar", kwargs={"pk": self.user.pk, "size": 200}
)
response = self.client.get(avatar_url)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["location"], self.user.avatars[1]["url"])
def test_get_user_avatar_inexact_size(self):
"""avatar server resolved valid avatar fallback for user"""
avatar_url = reverse(
"misago:user-avatar", kwargs={"pk": self.user.pk, "size": 250}
)
response = self.client.get(avatar_url)
self.assertEqual(response.status_code, 302)
self.assertEqual(response["location"], self.user.avatars[0]["url"])
def test_get_notfound_user_avatar(self):
"""avatar server handles deleted user avatar requests"""
avatar_url = reverse(
"misago:user-avatar", kwargs={"pk": self.user.pk + 1, "size": 150}
)
response = self.client.get(avatar_url)
self.assertEqual(response.status_code, 302)
self.assertTrue(response["location"].endswith(settings.MISAGO_BLANK_AVATAR))
def test_blank_avatar_serving(self):
"""avatar server handles blank avatar requests"""
response = self.client.get(reverse("misago:blank-avatar"))
self.assertEqual(response.status_code, 302)
self.assertTrue(response["location"].endswith(settings.MISAGO_BLANK_AVATAR))
| 1,787
|
Python
|
.py
| 36
| 41.611111
| 84
| 0.668585
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,488
|
test_prepareuserdatadownloads.py
|
rafalp_Misago/misago/users/tests/test_prepareuserdatadownloads.py
|
from io import StringIO
from django.core import mail
from django.core.management import call_command
from ...conf.test import override_dynamic_settings
from ..datadownloads import request_user_data_download
from ..management.commands import prepareuserdatadownloads
from ..models import DataDownload
from ..test import AuthenticatedUserTestCase
class PrepareUserDataDownloadsTests(AuthenticatedUserTestCase):
@override_dynamic_settings(forum_address="http://test.com/")
def test_process_pending_data_download(self):
"""management command processes pending data download"""
data_download = request_user_data_download(self.user)
self.assertEqual(data_download.status, DataDownload.STATUS_PENDING)
out = StringIO()
call_command(prepareuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads prepared: 1")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_READY)
self.assertTrue(updated_data_download.expires_on > data_download.expires_on)
self.assertTrue(updated_data_download.file)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(
mail.outbox[0].subject, "TestUser, your data download is ready"
)
absolute_url = "".join(["http://test.com", updated_data_download.file.url])
self.assertIn(absolute_url, mail.outbox[0].body)
def test_skip_ready_data_download(self):
"""management command skips ready data download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_READY
data_download.save()
out = StringIO()
call_command(prepareuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads prepared: 0")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_READY)
self.assertEqual(len(mail.outbox), 0)
def test_skip_processing_data_download(self):
"""management command skips processing data download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_PROCESSING
data_download.save()
out = StringIO()
call_command(prepareuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads prepared: 0")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_PROCESSING)
self.assertEqual(len(mail.outbox), 0)
def test_skip_expired_data_download(self):
"""management command skips expired data download"""
data_download = request_user_data_download(self.user)
data_download.status = DataDownload.STATUS_EXPIRED
data_download.save()
out = StringIO()
call_command(prepareuserdatadownloads.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Data downloads prepared: 0")
updated_data_download = DataDownload.objects.get(pk=data_download.pk)
self.assertEqual(updated_data_download.status, DataDownload.STATUS_EXPIRED)
self.assertEqual(len(mail.outbox), 0)
| 3,665
|
Python
|
.py
| 64
| 49.265625
| 86
| 0.720716
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,489
|
test_user_model.py
|
rafalp_Misago/misago/users/tests/test_user_model.py
|
from pathlib import Path
import pytest
from ...conf import settings
from ...core.utils import slugify
from ...permissions.permissionsid import get_permissions_id
from ..avatars import dynamic
from ..datadownloads import request_user_data_download
from ..models import Avatar, DataDownload, User
from ..utils import hash_email
def test_username_and_slug_is_anonymized(user):
user.anonymize_data(anonymous_username="Deleted")
assert user.username == "Deleted"
assert user.slug == slugify("Deleted")
def test_user_avatar_files_are_deleted_during_user_deletion(user):
dynamic.set_avatar(user)
user.save()
user_avatars = []
for avatar in user.avatar_set.all():
avatar_path = Path(avatar.image.path)
assert avatar_path.exists()
assert avatar_path.is_file()
user_avatars.append(avatar)
assert user_avatars
user.delete(anonymous_username="Deleted")
for removed_avatar in user_avatars:
avatar_path = Path(removed_avatar.image.path)
assert not avatar_path.exists()
assert not avatar_path.is_file()
with pytest.raises(Avatar.DoesNotExist):
Avatar.objects.get(pk=removed_avatar.pk)
def test_username_setter_also_sets_slug():
user = User()
user.set_username("TestUser")
assert user.username == "TestUser"
assert user.slug == "testuser"
def test_django_username_getters_return_username(user):
assert user.get_username() == user.username
assert user.get_full_name() == user.username
assert user.get_short_name() == user.username
def test_email_setter_normalizes_email():
user = User()
user.set_email("us3R@EXample.com")
assert user.email == "us3R@example.com"
def test_email_setter_also_sets_email_hash():
user = User()
user.set_email("us3R@example.com")
assert user.email_hash == hash_email("us3R@example.com")
def test_user_group_setter_updates_group_and_permissions_id(admins_group):
user = User()
user.set_groups(admins_group)
assert user.group == admins_group
assert user.groups_ids == [admins_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_user_group_setter_updates_secondary_groups(admins_group, members_group):
user = User()
user.set_groups(admins_group, [members_group])
assert user.group == admins_group
assert user.groups_ids == [admins_group.id, members_group.id]
assert user.permissions_id == get_permissions_id(user.groups_ids)
def test_real_name_getter_returns_name_entered_in_profile_field(user):
user.profile_fields["real_name"] = "John Doe"
assert user.get_real_name() == "John Doe"
def test_real_name_getter_returns_none_if_profile_field_has_no_value(user):
assert user.get_real_name() is None
def test_clear_unread_private_threads_does_nothing_if_user_has_zero_unread_threads(
user, django_assert_num_queries
):
with django_assert_num_queries(0):
user.clear_unread_private_threads()
def test_clear_unread_private_threads_zeros_user_unread_threads(
user, django_assert_num_queries
):
user.unread_private_threads = 5
user.sync_unread_private_threads = True
user.save()
with django_assert_num_queries(1):
user.clear_unread_private_threads()
assert user.unread_private_threads == 0
assert not user.sync_unread_private_threads
user.refresh_from_db()
assert user.unread_private_threads == 0
assert not user.sync_unread_private_threads
def test_marking_user_for_deletion_deactivates_their_account_in_db(user):
user.mark_for_delete()
assert not user.is_active
assert user.is_deleting_account
user.refresh_from_db()
assert not user.is_active
assert user.is_deleting_account
def test_user_data_downloads_are_removed_by_anonymization(user):
data_download = request_user_data_download(user)
user.anonymize_data(anonymous_username="Deleted")
with pytest.raises(DataDownload.DoesNotExist):
data_download.refresh_from_db()
def test_deleting_user_also_deletes_their_data_downloads(user):
data_download = request_user_data_download(user)
user.delete(anonymous_username="Deleted")
with pytest.raises(DataDownload.DoesNotExist):
data_download.refresh_from_db()
| 4,275
|
Python
|
.py
| 99
| 38.242424
| 83
| 0.733914
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,490
|
test_remove_group_from_users_groups_ids.py
|
rafalp_Misago/misago/users/tests/test_remove_group_from_users_groups_ids.py
|
from ...permissions.permissionsid import get_permissions_id
from ..tasks import remove_group_from_users_groups_ids
def test_remove_group_from_users_groups_ids_task_removes_group_from_user_groups_ids(
user, members_group, custom_group
):
user.set_groups(members_group, [custom_group])
user.save()
remove_group_from_users_groups_ids(custom_group.id)
user.refresh_from_db()
assert user.groups_ids == [members_group.id]
def test_remove_group_from_users_groups_ids_task_updates_user_permissions_id(
user, members_group, custom_group
):
user.set_groups(members_group, [custom_group])
user.save()
remove_group_from_users_groups_ids(custom_group.id)
user.refresh_from_db()
assert user.permissions_id == get_permissions_id([members_group.id])
| 790
|
Python
|
.py
| 18
| 39.777778
| 84
| 0.75
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,491
|
test_auth_views.py
|
rafalp_Misago/misago/users/tests/test_auth_views.py
|
from django.test import TestCase
from django.urls import reverse
from ...conf.test import override_dynamic_settings
class AuthViewsTests(TestCase):
def test_logout_view(self):
"""logout view logs user out on post"""
response = self.client.post(
"/api/auth/", data={"username": "nope", "password": "not-checked"}
)
self.assertContains(
response, "Login or password is incorrect.", status_code=400
)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
response = self.client.post(reverse("misago:logout"))
self.assertEqual(response.status_code, 302)
response = self.client.get("/api/auth/")
self.assertEqual(response.status_code, 200)
user_json = response.json()
self.assertIsNone(user_json["id"])
def test_logout_view_return_302(self):
"""logout view should always return redirect"""
response = self.client.get(reverse("misago:logout"))
self.assertEqual(response.status_code, 302)
response = self.client.post(reverse("misago:logout"))
self.assertEqual(response.status_code, 302)
| 1,277
|
Python
|
.py
| 28
| 37.357143
| 78
| 0.65832
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,492
|
test_delete_user_task.py
|
rafalp_Misago/misago/users/tests/test_delete_user_task.py
|
import pytest
from django.contrib.auth import get_user_model
from ..models.deleteduser import DeletedUser
from ..tasks import delete_user
User = get_user_model()
def test_delete_user_task_deletes_user(user):
delete_user(user.id)
with pytest.raises(User.DoesNotExist):
user.refresh_from_db()
def test_delete_user_task_records_user_deletion(user):
delete_user(user.id)
assert DeletedUser.objects.exists()
def test_delete_user_task_does_nothing_if_user_is_not_found(user):
delete_user(user.id + 1)
user.refresh_from_db()
| 561
|
Python
|
.py
| 15
| 33.533333
| 66
| 0.760748
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,493
|
test_user_feeds_api.py
|
rafalp_Misago/misago/users/tests/test_user_feeds_api.py
|
from django.urls import reverse
from ...threads import test
from ...threads.tests.test_threads_api import ThreadsApiTestCase
class UserThreadsApiTests(ThreadsApiTestCase):
def setUp(self):
super().setUp()
self.api_link = reverse("misago:api:user-threads", kwargs={"pk": self.user.pk})
def test_invalid_user_id(self):
"""api validates user id"""
link = reverse("misago:api:user-threads", kwargs={"pk": "abcd"})
response = self.client.get(link)
self.assertEqual(response.status_code, 404)
def test_nonexistant_user_id(self):
"""api validates that user for id exists"""
link = reverse("misago:api:user-threads", kwargs={"pk": self.user.pk + 1})
response = self.client.get(link)
self.assertEqual(response.status_code, 404)
def test_empty_response(self):
"""api has no showstopers on empty response"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 0)
def test_user_post(self):
"""user post doesn't show in feed because its not first post in thread"""
test.reply_thread(self.thread, poster=self.user)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 0)
def test_user_event(self):
"""events don't show in feeds at all"""
test.reply_thread(self.thread, poster=self.user, is_event=True)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 0)
def test_user_thread(self):
"""user thread shows in feed"""
thread = test.post_thread(category=self.category, poster=self.user)
# this post will not show in feed
test.reply_thread(thread, poster=self.user)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 1)
self.assertEqual(response.json()["results"][0]["id"], thread.first_post_id)
def test_user_thread_anonymous(self):
"""user thread shows in feed requested by unauthenticated user"""
thread = test.post_thread(category=self.category, poster=self.user)
self.logout_user()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 1)
self.assertEqual(response.json()["results"][0]["id"], thread.first_post_id)
class UserPostsApiTests(ThreadsApiTestCase):
def setUp(self):
super().setUp()
self.api_link = reverse("misago:api:user-posts", kwargs={"pk": self.user.pk})
def test_invalid_user_id(self):
"""api validates user id"""
link = reverse("misago:api:user-posts", kwargs={"pk": "abcd"})
response = self.client.get(link)
self.assertEqual(response.status_code, 404)
def test_nonexistant_user_id(self):
"""api validates that user for id exists"""
link = reverse("misago:api:user-posts", kwargs={"pk": self.user.pk + 1})
response = self.client.get(link)
self.assertEqual(response.status_code, 404)
def test_empty_response(self):
"""api has no showstopers on empty response"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 0)
def test_user_event(self):
"""events don't show in feeds at all"""
test.reply_thread(self.thread, poster=self.user, is_event=True)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 0)
def test_user_hidden_post(self):
"""hidden posts don't show in feeds at all"""
test.reply_thread(self.thread, poster=self.user, is_hidden=True)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 0)
def test_user_unapproved_post(self):
"""unapproved posts don't show in feeds at all"""
test.reply_thread(self.thread, poster=self.user, is_unapproved=True)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 0)
def test_user_posts(self):
"""user posts show in feed"""
post = test.reply_thread(self.thread, poster=self.user)
other_post = test.reply_thread(self.thread, poster=self.user)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 2)
self.assertEqual(response.json()["results"][0]["id"], other_post.pk)
self.assertEqual(response.json()["results"][1]["id"], post.pk)
def test_user_thread(self):
"""user thread shows in feed"""
thread = test.post_thread(category=self.category, poster=self.user)
post = test.reply_thread(thread, poster=self.user)
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 2)
self.assertEqual(response.json()["results"][0]["id"], post.pk)
self.assertEqual(response.json()["results"][1]["id"], thread.first_post_id)
def test_user_post_anonymous(self):
"""user post shows in feed requested by unauthenticated user"""
post = test.reply_thread(self.thread, poster=self.user)
other_post = test.reply_thread(self.thread, poster=self.user)
self.logout_user()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 2)
self.assertEqual(response.json()["results"][0]["id"], other_post.pk)
self.assertEqual(response.json()["results"][1]["id"], post.pk)
def test_user_thread_anonymous(self):
"""user thread shows in feed requested by unauthenticated user"""
thread = test.post_thread(category=self.category, poster=self.user)
post = test.reply_thread(thread, poster=self.user)
self.logout_user()
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()["results"]), 2)
self.assertEqual(response.json()["results"][0]["id"], post.pk)
self.assertEqual(response.json()["results"][1]["id"], thread.first_post_id)
| 6,834
|
Python
|
.py
| 126
| 45.849206
| 87
| 0.661868
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,494
|
test_joinip_profilefield.py
|
rafalp_Misago/misago/users/tests/test_joinip_profilefield.py
|
from django.contrib.auth import get_user_model
from django.urls import reverse
from ...acl.test import patch_user_acl
from ...admin.test import AdminTestCase
User = get_user_model()
class JoinIpProfileFieldTests(AdminTestCase):
def setUp(self):
super().setUp()
self.test_link = reverse("misago:admin:users:edit", kwargs={"pk": self.user.pk})
def test_field_hidden_in_admin(self):
"""readonly field doesn't display in the admin"""
response = self.client.get(self.test_link)
self.assertNotContains(response, 'name="join_ip"')
self.assertNotContains(response, "IP address")
self.assertNotContains(response, "Join IP")
def test_admin_edits_field(self):
"""join_ip is non-editable by admin"""
response = self.client.post(
self.test_link,
data={
"username": "Edited",
"group": str(self.user.group_id),
"rank": str(self.user.rank_id),
"roles": str(self.user.roles.all()[0].pk),
"email": "reg@stered.com",
"join_ip": "127.0.0.1",
"new_password": "",
"signature": "",
"is_signature_locked": "0",
"is_hiding_presence": "0",
"is_active": "1",
"limits_private_thread_invites_to": "0",
"signature_lock_staff_message": "",
"signature_lock_user_message": "",
"subscribe_to_started_threads": "2",
"subscribe_to_replied_threads": "2",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
},
)
self.assertEqual(response.status_code, 302)
self.reload_user()
self.assertNotIn("join_ip", self.user.profile_fields)
def test_admin_search_field(self):
"""admin users search searches this field"""
test_link = reverse("misago:admin:users:index")
response = self.client.get(
"%s?redirected=1&profilefields=127.0.0.1" % test_link
)
self.assertContains(response, "No users matching criteria exist.")
def test_field_display(self):
"""field displays on user profile"""
test_link = reverse(
"misago:user-details", kwargs={"pk": self.user.pk, "slug": self.user.slug}
)
response = self.client.get(test_link)
self.assertContains(response, "IP address")
self.assertContains(response, "Join IP")
self.assertContains(response, "127.0.0.1")
@patch_user_acl({"can_see_users_ips": 0})
def test_field_hidden_no_permission(self):
"""field is hidden on user profile if user has no permission"""
test_link = reverse(
"misago:user-details", kwargs={"pk": self.user.pk, "slug": self.user.slug}
)
response = self.client.get(test_link)
self.assertNotContains(response, "IP address")
self.assertNotContains(response, "Join IP")
self.assertNotContains(response, "127.0.0.1")
def test_field_hidden_ip_removed(self):
"""field is hidden on user profile if ip is removed"""
test_link = reverse(
"misago:user-details", kwargs={"pk": self.user.pk, "slug": self.user.slug}
)
self.user.joined_from_ip = None
self.user.save()
response = self.client.get(test_link)
self.assertNotContains(response, "IP address")
self.assertNotContains(response, "Join IP")
self.assertNotContains(response, "127.0.0.1")
def test_field_display_json(self):
"""field is included in display json"""
test_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
self.assertEqual(
response.json()["groups"],
[
{
"name": "IP address",
"fields": [
{"fieldname": "join_ip", "name": "Join IP", "text": "127.0.0.1"}
],
}
],
)
@patch_user_acl({"can_see_users_ips": 0})
def test_field_hidden_no_permission_json(self):
"""field is not included in display json if user has no permission"""
test_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
self.assertEqual(response.json()["groups"], [])
def test_field_hidden_ip_removed_json(self):
"""field is not included in display json if user ip is removed"""
test_link = reverse("misago:api:user-details", kwargs={"pk": self.user.pk})
self.user.joined_from_ip = None
self.user.save()
response = self.client.get(test_link)
self.assertEqual(response.json()["groups"], [])
def test_field_not_in_edit_json(self):
"""readonly field json is not returned from API"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.get(test_link)
found_field = None
for group in response.json():
for field in group["fields"]:
if field["fieldname"] == "join_ip":
found_field = field
self.assertIsNone(found_field)
def test_field_is_not_editable_in_api(self):
"""readonly field can't be edited via api"""
test_link = reverse("misago:api:user-edit-details", kwargs={"pk": self.user.pk})
response = self.client.post(test_link, data={"join_ip": "88.12.13.14"})
self.assertEqual(response.status_code, 200)
self.reload_user()
self.assertNotIn("join_ip", self.user.profile_fields)
| 6,034
|
Python
|
.py
| 129
| 35.953488
| 88
| 0.585291
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,495
|
test_rest_permissions.py
|
rafalp_Misago/misago/users/tests/test_rest_permissions.py
|
from django.urls import reverse
from ..models import Ban
from ..test import UserTestCase
class UnbannedOnlyTests(UserTestCase):
def setUp(self):
self.user = self.get_authenticated_user()
def test_api_allows_guests(self):
"""policy allows guests"""
response = self.client.post(
reverse("misago:api:send-password-form"), data={"email": self.user.email}
)
self.assertEqual(response.status_code, 200)
def test_api_allows_authenticated(self):
"""policy allows authenticated"""
self.login_user(self.user)
response = self.client.post(
reverse("misago:api:send-password-form"), data={"email": self.user.email}
)
self.assertEqual(response.status_code, 200)
def test_api_blocks_banned(self):
"""policy blocked banned ip"""
Ban.objects.create(
check_type=Ban.IP, banned_value="127.*", user_message="Ya got banned!"
)
response = self.client.post(
reverse("misago:api:send-password-form"), data={"email": self.user.email}
)
self.assertEqual(response.status_code, 403)
class UnbannedAnonOnlyTests(UserTestCase):
def setUp(self):
self.user = self.get_authenticated_user()
def test_api_allows_guests(self):
"""policy allows guests"""
self.user.requires_activation = 1
self.user.save()
response = self.client.post(
reverse("misago:api:send-activation"), data={"email": self.user.email}
)
self.assertEqual(response.status_code, 200)
def test_api_allows_authenticated(self):
"""policy blocks authenticated"""
self.login_user(self.user)
response = self.client.post(
reverse("misago:api:send-activation"), data={"email": self.user.email}
)
self.assertEqual(response.status_code, 403)
def test_api_blocks_banned(self):
"""policy blocked banned ip"""
Ban.objects.create(
check_type=Ban.IP, banned_value="127.*", user_message="Ya got banned!"
)
response = self.client.post(
reverse("misago:api:send-activation"), data={"email": self.user.email}
)
self.assertEqual(response.status_code, 403)
| 2,283
|
Python
|
.py
| 55
| 32.945455
| 85
| 0.63698
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,496
|
test_user_getters.py
|
rafalp_Misago/misago/users/tests/test_user_getters.py
|
import pytest
from django.contrib.auth import get_user_model
User = get_user_model()
def test_get_user_by_username(db):
user = User.objects.create_user("User", "test@example.com")
assert User.objects.get_by_username("User") == user
def test_getting_user_by_username_is_case_insensitive(db):
user = User.objects.create_user("User", "test@example.com")
assert User.objects.get_by_username("uSeR") == user
def test_getting_user_by_username_raises_does_not_exist_for_no_result(db):
with pytest.raises(User.DoesNotExist):
User.objects.get_by_username("user")
def test_getting_user_by_username_supports_diacritics(db):
with pytest.raises(User.DoesNotExist):
User.objects.get_by_username("łóć")
def test_getting_user_by_username_is_not_doing_fuzzy_matching(db):
User.objects.create_user("User", "test@example.com")
with pytest.raises(User.DoesNotExist):
User.objects.get_by_username("usar")
def test_get_user_by_email(db):
user = User.objects.create_user("User", "test@example.com")
assert User.objects.get_by_email("test@example.com") == user
def test_getting_user_by_email_is_case_insensitive(db):
user = User.objects.create_user("User", "test@example.com")
assert User.objects.get_by_email("tEsT@eXaMplE.com") == user
def test_getting_user_by_email_supports_diacritics(db):
user = User.objects.create_user("User", "łóć@łexĄmple.com")
assert User.objects.get_by_email("łÓć@ŁexĄMple.com") == user
def test_getting_user_by_email_raises_does_not_exist_for_no_result(db):
with pytest.raises(User.DoesNotExist):
User.objects.get_by_email("test@example.com")
def test_get_user_by_username_using_combined_getter(db):
user = User.objects.create_user("User", "test@example.com")
assert User.objects.get_by_username_or_email("user") == user
def test_get_user_by_email_using_combined_getter(db):
user = User.objects.create_user("User", "test@example.com")
assert User.objects.get_by_username_or_email("test@example.com") == user
def test_combined_getter_handles_username_slug_and_email_collision(db):
email_match = User.objects.create_user("Bob", "test@test.test")
slug_match = User.objects.create_user("TestTestTest", "other@test.com")
assert User.objects.get_by_username_or_email("test@test.test") == email_match
assert User.objects.get_by_username_or_email("TestTestTest") == slug_match
def test_combined_getter_raises_does_not_exist_for_no_result(db):
with pytest.raises(User.DoesNotExist):
User.objects.get_by_username_or_email("User")
| 2,602
|
Python
|
.py
| 45
| 52.888889
| 81
| 0.734102
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,497
|
test_profilefields.py
|
rafalp_Misago/misago/users/tests/test_profilefields.py
|
from django.contrib.auth import get_user_model
from django.test import TestCase
from ..profilefields import ProfileFields
User = get_user_model()
class ProfileFieldsLoadTests(TestCase):
def test_no_groups(self):
"""profile fields util handles empty list"""
profilefields = ProfileFields([])
profilefields.load()
self.assertFalse(profilefields.fields_dict)
def test_empty_group(self):
"""profile fields util handles empty group"""
profilefields = ProfileFields([{"name": "Test", "fields": []}])
profilefields.load()
self.assertFalse(profilefields.fields_dict)
def test_field_defines_fieldname(self):
"""fields need to define fieldname"""
profilefields = ProfileFields(
[
{
"name": "Test",
"fields": [
"misago.users.tests.testfiles.profilefields.NofieldnameField"
],
}
]
)
with self.assertRaises(ValueError):
profilefields.load()
try:
profilefields.load()
except ValueError as e:
error = str(e)
self.assertIn(
"misago.users.tests.testfiles.profilefields.NofieldnameField", error
)
self.assertIn("profile field has to specify fieldname attribute", error)
def test_detect_repeated_imports(self):
"""fields can't be specified multiple times"""
profilefields = ProfileFields(
[
{
"name": "Test",
"fields": ["misago.users.profilefields.default.TwitterHandleField"],
},
{
"name": "Other test",
"fields": ["misago.users.profilefields.default.TwitterHandleField"],
},
]
)
with self.assertRaises(ValueError):
profilefields.load()
try:
profilefields.load()
except ValueError as e:
error = str(e)
self.assertIn(
"misago.users.profilefields.default.TwitterHandleField", error
)
self.assertIn("profile field has been specified twice", error)
def test_detect_repeated_fieldnames(self):
"""fields can't reuse other field's fieldnames"""
profilefields = ProfileFields(
[
{
"name": "Test",
"fields": [
"misago.users.tests.testfiles.profilefields.FieldnameField"
],
},
{
"name": "Other test",
"fields": [
# pylint: disable=line-too-long
"misago.users.tests.testfiles.profilefields.RepeatedFieldnameField"
],
},
]
)
with self.assertRaises(ValueError):
profilefields.load()
try:
profilefields.load()
except ValueError as e:
error = str(e)
self.assertIn(
"misago.users.tests.testfiles.profilefields.FieldnameField", error
)
self.assertIn(
"misago.users.tests.testfiles.profilefields.RepeatedFieldnameField",
error,
)
self.assertIn(
'field defines fieldname "hello" that is already in use by the', error
)
def test_field_correct_field(self):
"""util loads correct field"""
field_path = "misago.users.profilefields.default.RealNameField"
profilefields = ProfileFields([{"name": "Test", "fields": [field_path]}])
profilefields.load()
self.assertIn(field_path, profilefields.fields_dict)
| 3,893
|
Python
|
.py
| 102
| 25.088235
| 91
| 0.539952
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,498
|
test_deleteinactiveusers.py
|
rafalp_Misago/misago/users/tests/test_deleteinactiveusers.py
|
from datetime import timedelta
from io import StringIO
from django.contrib.auth import get_user_model
from django.core.management import call_command
from django.test import TestCase
from django.utils import timezone
from ...conf.test import override_dynamic_settings
from ..management.commands import deleteinactiveusers
from ..models import DeletedUser
from ..test import create_test_user
User = get_user_model()
class DeleteInactiveUsersTests(TestCase):
def setUp(self):
self.user = create_test_user("User", "user@example.com")
@override_dynamic_settings(new_inactive_accounts_delete=2)
def test_delete_user_activation_user(self):
"""deletes user that didn't activate their account within required time"""
self.user.joined_on = timezone.now() - timedelta(days=2)
self.user.requires_activation = User.ACTIVATION_USER
self.user.save()
out = StringIO()
call_command(deleteinactiveusers.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Deleted inactive user accounts: 1")
with self.assertRaises(User.DoesNotExist):
self.user.refresh_from_db()
@override_dynamic_settings(new_inactive_accounts_delete=2)
def test_delete_user_activation_admin(self):
"""deletes user that wasn't activated by admin within required time"""
self.user.joined_on = timezone.now() - timedelta(days=2)
self.user.requires_activation = User.ACTIVATION_ADMIN
self.user.save()
out = StringIO()
call_command(deleteinactiveusers.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Deleted inactive user accounts: 1")
with self.assertRaises(User.DoesNotExist):
self.user.refresh_from_db()
@override_dynamic_settings(new_inactive_accounts_delete=2)
def test_inactive_user_deletion_is_recorded(self):
self.user.joined_on = timezone.now() - timedelta(days=2)
self.user.requires_activation = User.ACTIVATION_USER
self.user.save()
out = StringIO()
call_command(deleteinactiveusers.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Deleted inactive user accounts: 1")
DeletedUser.objects.get(deleted_by=DeletedUser.DELETED_BY_SYSTEM)
@override_dynamic_settings(new_inactive_accounts_delete=2)
def test_skip_new_user_activation_user(self):
"""skips inactive user that is too new"""
self.user.joined_on = timezone.now() - timedelta(days=1)
self.user.requires_activation = User.ACTIVATION_USER
self.user.save()
out = StringIO()
call_command(deleteinactiveusers.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Deleted inactive user accounts: 0")
self.user.refresh_from_db()
@override_dynamic_settings(new_inactive_accounts_delete=2)
def test_skip_new_user_activation_admin(self):
"""skips admin-activated user that is too new"""
self.user.joined_on = timezone.now() - timedelta(days=1)
self.user.requires_activation = User.ACTIVATION_ADMIN
self.user.save()
out = StringIO()
call_command(deleteinactiveusers.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Deleted inactive user accounts: 0")
self.user.refresh_from_db()
@override_dynamic_settings(new_inactive_accounts_delete=2)
def test_skip_active_user(self):
"""skips active user"""
self.user.joined_on = timezone.now() - timedelta(days=1)
self.user.save()
out = StringIO()
call_command(deleteinactiveusers.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(command_output, "Deleted inactive user accounts: 0")
self.user.refresh_from_db()
@override_dynamic_settings(new_inactive_accounts_delete=0)
def test_delete_inactive_is_disabled(self):
"""skips active user"""
self.user.joined_on = timezone.now() - timedelta(days=1)
self.user.requires_activation = User.ACTIVATION_ADMIN
self.user.save()
out = StringIO()
call_command(deleteinactiveusers.Command(), stdout=out)
command_output = out.getvalue().splitlines()[0].strip()
self.assertEqual(
command_output,
"Automatic deletion of inactive user accounts is currently disabled.",
)
self.user.refresh_from_db()
| 4,773
|
Python
|
.py
| 94
| 42.914894
| 82
| 0.692854
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,499
|
test_user_editdetails_api.py
|
rafalp_Misago/misago/users/tests/test_user_editdetails_api.py
|
from django.urls import reverse
from ...acl.test import patch_user_acl
from ..test import AuthenticatedUserTestCase, create_test_user
class UserEditDetailsApiTests(AuthenticatedUserTestCase):
def setUp(self):
super().setUp()
self.api_link = reverse(
"misago:api:user-edit-details", kwargs={"pk": self.user.pk}
)
def get_profile_fields(self):
self.user.refresh_from_db()
return self.user.profile_fields
def test_api_has_no_showstoppers(self):
"""api outputs response for freshly created user"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_api_has_no_showstoppers_old_user(self):
"""api outputs response for freshly created user"""
response = self.client.get(self.api_link)
self.assertEqual(response.status_code, 200)
def test_other_user(self):
"""api handles scenario when its other user looking at profile"""
test_user = create_test_user("Other_User", "otheruser@example.com")
api_link = reverse("misago:api:user-edit-details", kwargs={"pk": test_user.pk})
# moderator has permission to edit details
with patch_user_acl({"can_moderate_profile_details": True}):
response = self.client.get(api_link)
self.assertEqual(response.status_code, 200)
# non-moderator has no permission to edit details
with patch_user_acl({"can_moderate_profile_details": False}):
response = self.client.get(api_link)
self.assertEqual(response.status_code, 403)
def test_nonexistant_user(self):
"""api handles nonexistant users"""
api_link = reverse(
"misago:api:user-edit-details", kwargs={"pk": self.user.pk + 123}
)
response = self.client.get(api_link)
self.assertEqual(response.status_code, 404)
def test_api_updates_text_field(self):
"""api updates text field"""
response = self.client.post(
self.api_link, data={"bio": "I have some, as is tradition."}
)
self.assertEqual(response.status_code, 200)
profile_fields = self.get_profile_fields()
self.assertEqual(profile_fields["bio"], "I have some, as is tradition.")
response_json = response.json()
self.assertEqual(response_json["id"], self.user.id)
self.assertTrue(response_json["edit"])
self.assertTrue(response_json["groups"])
def test_api_updates_select_field(self):
"""api updates select field"""
response = self.client.post(self.api_link, data={"gender": "female"})
self.assertEqual(response.status_code, 200)
profile_fields = self.get_profile_fields()
self.assertEqual(profile_fields["gender"], "female")
response_json = response.json()
self.assertEqual(response_json["id"], self.user.id)
self.assertTrue(response_json["edit"])
self.assertTrue(response_json["groups"])
def test_api_validates_url_field(self):
"""api runs basic validation against url fields"""
response = self.client.post(self.api_link, data={"website": "noturl"})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"website": ["Enter a valid URL."]})
def test_api_cleans_url_field(self):
"""api cleans url fields"""
response = self.client.post(self.api_link, data={"website": "onet.pl"})
self.assertEqual(response.status_code, 200)
profile_fields = self.get_profile_fields()
self.assertEqual(profile_fields["website"], "http://onet.pl")
response_json = response.json()
self.assertEqual(response_json["id"], self.user.id)
self.assertTrue(response_json["edit"])
self.assertTrue(response_json["groups"])
def test_api_custom_cleans_url_field(self):
"""api calls fields clean method"""
response = self.client.post(self.api_link, data={"twitter": "@Weebl"})
self.assertEqual(response.status_code, 200)
profile_fields = self.get_profile_fields()
self.assertEqual(profile_fields["twitter"], "Weebl")
response_json = response.json()
self.assertEqual(response_json["id"], self.user.id)
self.assertTrue(response_json["edit"])
self.assertTrue(response_json["groups"])
| 4,406
|
Python
|
.py
| 86
| 42.44186
| 87
| 0.656643
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|