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,900
|
test_google_form.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_google_form.py
|
import pytest
from django.urls import reverse
from ...models import SocialAuthProvider
admin_link = reverse(
"misago:admin:settings:socialauth:edit", kwargs={"pk": "google-oauth2"}
)
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(
provider="google-oauth2", is_active=True, order=0
)
def test_google_form_can_be_accessed(admin_client):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_google_login_can_be_setup(admin_client):
admin_client.post(
admin_link,
{
"is_active": "1",
"associate_by_email": "1",
"key": "test-key",
"secret": "test-secret",
},
)
provider = SocialAuthProvider.objects.get(provider="google-oauth2")
assert provider.is_active
assert provider.settings == {
"associate_by_email": 1,
"key": "test-key",
"secret": "test-secret",
}
def test_google_login_can_be_disabled(admin_client, provider):
admin_client.post(admin_link, {"is_active": "0"})
provider = SocialAuthProvider.objects.get(provider="google-oauth2")
assert not provider.is_active
def test_google_login_form_requires_key_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "secret": "test-secret"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="google-oauth2")
def test_google_login_form_requires_secret_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "key": "test-key"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="google-oauth2")
| 1,727
|
Python
|
.py
| 43
| 34.255814
| 78
| 0.69009
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,901
|
test_editing_provider.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_editing_provider.py
|
from django.urls import reverse
from ....cache.test import assert_invalidates_cache
from ....test import assert_contains
from ... import SOCIALAUTH_CACHE
from ...models import SocialAuthProvider
def test_form_displays_for_enabled_provider(admin_client, provider):
response = admin_client.get(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": provider.pk})
)
assert response.status_code == 200
def test_form_displays_for_disabled_provider(admin_client, disabled_provider):
response = admin_client.get(
reverse(
"misago:admin:settings:socialauth:edit", kwargs={"pk": disabled_provider.pk}
)
)
assert response.status_code == 200
def test_form_displays_for_unset_provider(admin_client):
response = admin_client.get(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": "facebook"})
)
assert response.status_code == 200
def test_form_handles_undefined_provider(admin_client):
response = admin_client.get(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": "undefined"})
)
assert response.status_code == 302
def test_form_displays_provider_settings(admin_client, provider):
provider.settings = {"key": "test-key", "secret": "test-secret"}
provider.save()
response = admin_client.get(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": provider.pk})
)
assert_contains(response, "test-key")
assert_contains(response, "test-secret")
def test_form_updates_provider_settings(admin_client, provider):
admin_client.post(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": provider.pk}),
{"key": "test-key", "secret": "test-secret"},
)
provider.refresh_from_db()
assert provider.settings == {
"associate_by_email": 0,
"key": "test-key",
"secret": "test-secret",
}
def test_form_updates_provider_button_text(admin_client, provider):
admin_client.post(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": provider.pk}),
{"button_text": "Hello world!"},
)
provider.refresh_from_db()
assert provider.button_text == "Hello world!"
def test_form_updates_provider_button_color(admin_client, provider):
admin_client.post(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": provider.pk}),
{"button_color": "#ff00ff"},
)
provider.refresh_from_db()
assert provider.button_color == "#ff00ff"
def test_form_invalidates_providers_cache(admin_client, provider):
with assert_invalidates_cache(SOCIALAUTH_CACHE):
admin_client.post(
reverse(
"misago:admin:settings:socialauth:edit", kwargs={"pk": provider.pk}
),
{"is_active": "0"},
)
def test_form_sets_provider_order_on_setup(admin_client, other_provider):
admin_client.post(
reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": "facebook"}),
{"is_active": "1", "key": "test-key", "secret": "test-secret"},
)
provider = SocialAuthProvider.objects.get(pk="facebook")
assert provider.order == other_provider.order + 1
| 3,216
|
Python
|
.py
| 75
| 36.72
| 88
| 0.679512
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,902
|
test_github_form.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_github_form.py
|
import pytest
from django.urls import reverse
from ...models import SocialAuthProvider
admin_link = reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": "github"})
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(provider="github", is_active=True, order=0)
def test_github_form_can_be_accessed(admin_client):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_github_login_can_be_setup(admin_client):
admin_client.post(
admin_link,
{
"is_active": "1",
"associate_by_email": "1",
"key": "test-key",
"secret": "test-secret",
},
)
provider = SocialAuthProvider.objects.get(provider="github")
assert provider.is_active
assert provider.settings == {
"associate_by_email": 1,
"key": "test-key",
"secret": "test-secret",
}
def test_github_login_can_be_disabled(admin_client, provider):
admin_client.post(admin_link, {"is_active": "0"})
provider = SocialAuthProvider.objects.get(provider="github")
assert not provider.is_active
def test_github_login_form_requires_key_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "secret": "test-secret"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="github")
def test_github_login_form_requires_secret_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "key": "test-key"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="github")
| 1,665
|
Python
|
.py
| 39
| 36.692308
| 88
| 0.692595
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,903
|
test_disabling_providers.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_disabling_providers.py
|
import pytest
from django.urls import reverse
from ....cache.test import assert_invalidates_cache
from ... import SOCIALAUTH_CACHE
@pytest.fixture
def admin_link(provider):
return reverse(
"misago:admin:settings:socialauth:disable", kwargs={"pk": provider.pk}
)
def test_provider_can_be_disabled(admin_client, admin_link, provider):
admin_client.post(admin_link)
provider.refresh_from_db()
assert not provider.is_active
def test_disabling_provider_invalidates_cache(admin_client, admin_link):
with assert_invalidates_cache(SOCIALAUTH_CACHE):
admin_client.post(admin_link)
def test_already_disabled_provider_cant_be_disabled(admin_client, disabled_provider):
admin_link = reverse(
"misago:admin:settings:socialauth:disable", kwargs={"pk": disabled_provider.pk}
)
admin_client.post(admin_link)
disabled_provider.refresh_from_db()
assert not disabled_provider.is_active
def test_provider_that_wasnt_setup_yet_cant_be_disabled(admin_client):
admin_link = reverse(
"misago:admin:settings:socialauth:disable", kwargs={"pk": "github"}
)
response = admin_client.post(admin_link)
assert response.status_code == 302
def test_undefined_provider_cant_be_disabled(admin_client):
admin_link = reverse(
"misago:admin:settings:socialauth:disable", kwargs={"pk": "undefined"}
)
response = admin_client.post(admin_link)
assert response.status_code == 302
| 1,466
|
Python
|
.py
| 35
| 37.2
| 87
| 0.74048
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,904
|
test_twitter_form.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_twitter_form.py
|
import pytest
from django.urls import reverse
from ...models import SocialAuthProvider
admin_link = reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": "twitter"})
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(
provider="twitter", is_active=True, order=0
)
def test_twitter_form_can_be_accessed(admin_client):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_twitter_login_can_be_setup(admin_client):
admin_client.post(
admin_link,
{
"is_active": "1",
"associate_by_email": "1",
"key": "test-key",
"secret": "test-secret",
},
)
provider = SocialAuthProvider.objects.get(provider="twitter")
assert provider.is_active
assert provider.settings == {
"associate_by_email": 1,
"key": "test-key",
"secret": "test-secret",
}
def test_twitter_login_can_be_disabled(admin_client, provider):
admin_client.post(admin_link, {"is_active": "0"})
provider = SocialAuthProvider.objects.get(provider="twitter")
assert not provider.is_active
def test_twitter_login_form_requires_key_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "secret": "test-secret"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="twitter")
def test_twitter_login_form_requires_secret_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "key": "test-key"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="twitter")
| 1,690
|
Python
|
.py
| 41
| 35.170732
| 87
| 0.689571
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,905
|
test_facebook_form.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_facebook_form.py
|
import pytest
from django.urls import reverse
from ...models import SocialAuthProvider
admin_link = reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": "facebook"})
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(
provider="facebook", is_active=True, order=0
)
def test_facebook_form_can_be_accessed(admin_client):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_facebook_login_can_be_setup(admin_client):
admin_client.post(
admin_link,
{
"is_active": "1",
"associate_by_email": "1",
"key": "test-key",
"secret": "test-secret",
},
)
provider = SocialAuthProvider.objects.get(provider="facebook")
assert provider.is_active
assert provider.settings == {
"associate_by_email": 1,
"key": "test-key",
"secret": "test-secret",
}
def test_facebook_login_can_be_disabled(admin_client, provider):
admin_client.post(admin_link, {"is_active": "0"})
provider = SocialAuthProvider.objects.get(provider="facebook")
assert not provider.is_active
def test_facebook_login_form_requires_key_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "secret": "test-secret"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="facebook")
def test_facebook_login_form_requires_secret_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "key": "test-key"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="facebook")
| 1,701
|
Python
|
.py
| 41
| 35.439024
| 88
| 0.691651
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,906
|
test_ordering_providers.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_ordering_providers.py
|
from django.urls import reverse
from ....cache.test import assert_invalidates_cache
from ... import SOCIALAUTH_CACHE
def test_top_provider_can_be_moved_down(admin_client, provider, other_provider):
provider.order = 0
provider.save()
other_provider.order = 1
other_provider.save()
admin_client.post(
reverse("misago:admin:settings:socialauth:down", kwargs={"pk": provider.pk})
)
provider.refresh_from_db()
assert provider.order == 1
other_provider.refresh_from_db()
assert other_provider.order == 0
def test_top_provider_cant_be_moved_up(admin_client, provider, other_provider):
provider.order = 0
provider.save()
other_provider.order = 1
other_provider.save()
admin_client.post(
reverse("misago:admin:settings:socialauth:up", kwargs={"pk": provider.pk})
)
provider.refresh_from_db()
assert provider.order == 0
other_provider.refresh_from_db()
assert other_provider.order == 1
def test_bottom_provider_cant_be_moved_down(admin_client, provider, other_provider):
provider.order = 1
provider.save()
other_provider.order = 0
other_provider.save()
admin_client.post(
reverse("misago:admin:settings:socialauth:down", kwargs={"pk": provider.pk})
)
provider.refresh_from_db()
assert provider.order == 1
other_provider.refresh_from_db()
assert other_provider.order == 0
def test_bottom_provider_can_be_moved_up(admin_client, provider, other_provider):
provider.order = 1
provider.save()
other_provider.order = 0
other_provider.save()
admin_client.post(
reverse("misago:admin:settings:socialauth:up", kwargs={"pk": provider.pk})
)
provider.refresh_from_db()
assert provider.order == 0
other_provider.refresh_from_db()
assert other_provider.order == 1
def test_moving_provider_down_invalidates_providers_cache(
admin_client, provider, other_provider
):
provider.order = 0
provider.save()
other_provider.order = 1
other_provider.save()
with assert_invalidates_cache(SOCIALAUTH_CACHE):
admin_client.post(
reverse("misago:admin:settings:socialauth:down", kwargs={"pk": provider.pk})
)
def test_moving_provider_up_invalidates_providers_cache(
admin_client, provider, other_provider
):
provider.order = 1
provider.save()
other_provider.order = 0
other_provider.save()
with assert_invalidates_cache(SOCIALAUTH_CACHE):
admin_client.post(
reverse("misago:admin:settings:socialauth:up", kwargs={"pk": provider.pk})
)
def test_disabled_provider_cant_be_moved_down(
admin_client, disabled_provider, provider
):
provider.order = 1
provider.save()
disabled_provider.order = 0
disabled_provider.save()
admin_client.post(
reverse(
"misago:admin:settings:socialauth:down", kwargs={"pk": disabled_provider.pk}
)
)
disabled_provider.refresh_from_db()
assert disabled_provider.order == 0
provider.refresh_from_db()
assert provider.order == 1
def test_disabled_provider_cant_be_moved_up(admin_client, disabled_provider, provider):
provider.order = 0
provider.save()
disabled_provider.order = 1
disabled_provider.save()
admin_client.post(
reverse(
"misago:admin:settings:socialauth:up", kwargs={"pk": disabled_provider.pk}
)
)
disabled_provider.refresh_from_db()
assert disabled_provider.order == 1
provider.refresh_from_db()
assert provider.order == 0
def test_moving_up_not_setup_provider_has_no_errors(admin_client):
response = admin_client.post(
reverse("misago:admin:settings:socialauth:up", kwargs={"pk": "facebook"})
)
assert response.status_code == 302
def test_moving_down_not_setup_provider_has_no_errors(admin_client):
response = admin_client.post(
reverse("misago:admin:settings:socialauth:down", kwargs={"pk": "facebook"})
)
assert response.status_code == 302
def test_moving_up_undefined_provider_has_no_errors(admin_client):
response = admin_client.post(
reverse("misago:admin:settings:socialauth:up", kwargs={"pk": "undefined"})
)
assert response.status_code == 302
def test_moving_down_undefined_provider_has_no_errors(admin_client):
response = admin_client.post(
reverse("misago:admin:settings:socialauth:down", kwargs={"pk": "undefined"})
)
assert response.status_code == 302
| 4,526
|
Python
|
.py
| 123
| 31.219512
| 88
| 0.699036
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,907
|
test_discord_form.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_discord_form.py
|
import pytest
from django.urls import reverse
from ...models import SocialAuthProvider
admin_link = reverse("misago:admin:settings:socialauth:edit", kwargs={"pk": "discord"})
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(
provider="discord", is_active=True, order=0
)
def test_discord_form_can_be_accessed(admin_client):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_discord_login_can_be_setup(admin_client):
admin_client.post(
admin_link,
{
"is_active": "1",
"associate_by_email": "1",
"key": "test-key",
"secret": "test-secret",
},
)
provider = SocialAuthProvider.objects.get(provider="discord")
assert provider.is_active
assert provider.settings == {
"associate_by_email": 1,
"key": "test-key",
"secret": "test-secret",
}
def test_discord_login_can_be_disabled(admin_client, provider):
admin_client.post(admin_link, {"is_active": "0"})
provider = SocialAuthProvider.objects.get(provider="discord")
assert not provider.is_active
def test_discord_login_form_requires_key_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "secret": "test-secret"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="discord")
def test_discord_login_form_requires_secret_to_setup(admin_client):
admin_client.post(admin_link, {"is_active": "1", "key": "test-key"})
with pytest.raises(SocialAuthProvider.DoesNotExist):
SocialAuthProvider.objects.get(provider="discord")
| 1,690
|
Python
|
.py
| 41
| 35.170732
| 87
| 0.689571
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,908
|
daterelative.py
|
rafalp_Misago/misago/formats/daterelative.py
|
from datetime import datetime, timedelta
from math import floor
from django.utils import timezone
from django.utils.formats import date_format
from django.utils.translation import npgettext, pgettext
def date_relative(value: datetime) -> str:
now = timezone.now()
delta = abs((now - value).total_seconds())
past = value < now
if delta < 60:
return pgettext("time ago", "moment ago")
if delta < 60 * 47:
minutes = round(delta / 60)
if past:
return npgettext(
"minutes ago",
"%(time)s minute ago",
"%(time)s minutes ago",
minutes,
) % {"time": minutes}
return npgettext(
"minutes in future",
"In %(time)s minute",
"In %(time)s minutes",
minutes,
) % {"time": minutes}
if delta < 3600 * 3:
hours = round(delta / 3600)
if past:
return npgettext(
"hours ago",
"%(time)s hour ago",
"%(time)s hours ago",
hours,
) % {"time": hours}
return npgettext(
"hours in future",
"In %(time)s hour",
"In %(time)s hours",
hours,
) % {"time": hours}
if is_same_day(now, value):
if past:
return time_short(value)
return pgettext("day at time", "Today at %(time)s") % {
"time": time_short(value)
}
if is_yesterday(now, value):
return pgettext("day at time", "Yesterday at %(time)s") % {
"time": time_short(value)
}
if is_tomorrow(now, value):
return pgettext("day at time", "Tomorrow at %(time)s") % {
"time": time_short(value)
}
if past and delta < 3600 * 24 * 6:
return pgettext("day at time", "%(day)s at %(time)s") % {
"day": date_format(value, "l"),
"time": time_short(value),
}
if is_same_year(now, value):
return date_format(value, pgettext("same year date", "F j"))
return date_format(value, pgettext("other year date", "F j, Y"))
def is_same_day(now: datetime, datetime_: datetime) -> bool:
return date_format(now, "dmY") == date_format(datetime_, "dmY")
def is_yesterday(now: datetime, datetime_: datetime) -> bool:
yesterday = now - timedelta(hours=24)
return date_format(yesterday, "dmY") == date_format(datetime_, "dmY")
def is_tomorrow(now: datetime, datetime_: datetime) -> bool:
yesterday = now + timedelta(hours=24)
return date_format(yesterday, "dmY") == date_format(datetime_, "dmY")
def is_same_year(now: datetime, datetime_: datetime) -> bool:
return date_format(now, "Y") == date_format(datetime_, "Y")
def date_relative_short(value: datetime) -> str:
now = timezone.now()
delta = abs((now - value).total_seconds())
if delta < 60:
return pgettext("time ago", "now")
if delta < 60 * 55:
minutes = round(delta / 60)
return pgettext("short minutes", "%(time)sm") % {"time": minutes}
if delta < 3600 * 24:
hours = round(delta / 3600)
return pgettext("short hours", "%(time)sh") % {"time": hours}
if delta < 86400 * 7:
days = round(delta / 86400)
return pgettext("short days", "%(time)sd") % {"time": days}
if now.year == value.year:
return date_format(value, pgettext("short this year", "M j"))
return date_format(value, pgettext("short other year", "M Y"))
def time_short(value: datetime) -> str:
return date_format(
value,
pgettext("time short", "g:i A"),
use_l10n=False,
)
| 3,701
|
Python
|
.py
| 96
| 29.958333
| 73
| 0.56467
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,909
|
apps.py
|
rafalp_Misago/misago/formats/apps.py
|
from django.apps import AppConfig
class MisagoFormatsConfig(AppConfig):
name = "misago.formats"
label = "misago_formats"
verbose_name = "Misago Formats"
| 167
|
Python
|
.py
| 5
| 29.6
| 37
| 0.75625
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,910
|
misago_formats.py
|
rafalp_Misago/misago/formats/templatetags/misago_formats.py
|
from django import template
from ..daterelative import date_relative, date_relative_short
register = template.Library()
register.filter(is_safe=False, expects_localtime=True)(date_relative)
register.filter(is_safe=False, expects_localtime=True)(date_relative_short)
| 269
|
Python
|
.py
| 5
| 52.2
| 75
| 0.831418
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,911
|
test_date_relative_short.py
|
rafalp_Misago/misago/formats/tests/test_date_relative_short.py
|
from datetime import timedelta
from django.utils import timezone
from freezegun import freeze_time
from ..daterelative import date_relative_short
def test_date_relative_short_formats_recent_date():
assert date_relative_short(timezone.now()) == "now"
def test_date_relative_short_formats_date_few_minutes_ago():
timestamp = timezone.now() - timedelta(minutes=5)
assert date_relative_short(timestamp) == "5m"
def test_date_relative_short_formats_date_few_hours_ago():
timestamp = timezone.now() - timedelta(hours=5)
assert date_relative_short(timestamp) == "5h"
def test_date_relative_short_formats_date_few_days_ago():
timestamp = timezone.now() - timedelta(hours=5 * 24)
assert date_relative_short(timestamp) == "5d"
@freeze_time("2024-07-27 15:12")
def test_date_relative_short_formats_date_from_this_year():
timestamp = timezone.now() - timedelta(days=100)
assert date_relative_short(timestamp) == "Apr 18"
@freeze_time("2024-07-27 15:12")
def test_date_relative_short_formats_date_from_other_year():
timestamp = timezone.now() - timedelta(days=400)
assert date_relative_short(timestamp) == "Jun 2023"
| 1,162
|
Python
|
.py
| 23
| 47
| 60
| 0.745778
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,912
|
test_date_relative.py
|
rafalp_Misago/misago/formats/tests/test_date_relative.py
|
from datetime import timedelta
from django.utils import timezone
from freezegun import freeze_time
from ..daterelative import date_relative
def test_date_relative_formats_recent_date():
assert date_relative(timezone.now()) == "moment ago"
def test_date_relative_formats_date_few_seconds_ago():
timestamp = timezone.now() - timedelta(seconds=5)
assert date_relative(timestamp) == "moment ago"
def test_date_relative_formats_date_few_seconds_in_future():
timestamp = timezone.now() + timedelta(seconds=5)
assert date_relative(timestamp) == "moment ago"
def test_date_relative_formats_date_few_minutes_ago():
timestamp = timezone.now() - timedelta(minutes=5)
assert date_relative(timestamp) == "5 minutes ago"
def test_date_relative_formats_date_few_minutes_in_future():
timestamp = timezone.now() + timedelta(minutes=5)
assert date_relative(timestamp) == "In 5 minutes"
def test_date_relative_formats_date_few_hours_ago():
timestamp = timezone.now() - timedelta(hours=2)
assert date_relative(timestamp) == "2 hours ago"
def test_date_relative_formats_date_few_hours_in_future():
timestamp = timezone.now() + timedelta(hours=2)
assert date_relative(timestamp) == "In 2 hours"
@freeze_time("2024-07-27 21:37")
def test_date_relative_formats_date_today():
timestamp = timezone.now() - timedelta(hours=7)
assert date_relative(timestamp) == "2:37 PM"
@freeze_time("2024-07-27 11:37")
def test_date_relative_formats_date_today_in_future():
timestamp = timezone.now() + timedelta(hours=7)
assert date_relative(timestamp) == "Today at 6:37 PM"
@freeze_time("2024-07-27 15:12")
def test_date_relative_formats_date_yesterday():
timestamp = timezone.now() - timedelta(hours=24)
assert date_relative(timestamp) == "Yesterday at 3:12 PM"
@freeze_time("2024-07-27 15:12")
def test_date_relative_formats_date_tomorrow():
timestamp = timezone.now() + timedelta(hours=24)
assert date_relative(timestamp) == "Tomorrow at 3:12 PM"
@freeze_time("2024-07-27 15:12")
def test_date_relative_formats_date_few_days_ago():
timestamp = timezone.now() - timedelta(hours=72)
assert date_relative(timestamp) == "Wednesday at 3:12 PM"
@freeze_time("2024-07-23 00:00")
def test_date_relative_uses_hours_instead_of_midnight():
timestamp = timezone.now() - timedelta(hours=24)
assert date_relative(timestamp) == "Yesterday at 12:00 AM"
@freeze_time("2024-07-23 00:00")
def test_date_relative_uses_day_and_month_for_past_date_this_year():
timestamp = timezone.now() - timedelta(days=100)
assert date_relative(timestamp) == "April 14"
@freeze_time("2024-07-23 00:00")
def test_date_relative_uses_day_and_month_for_future_date_this_year():
timestamp = timezone.now() + timedelta(days=100)
assert date_relative(timestamp) == "October 31"
@freeze_time("2024-07-23 00:00")
def test_date_relative_uses_day_and_month_for_date_previous_year():
timestamp = timezone.now() - timedelta(days=400)
assert date_relative(timestamp) == "June 19, 2023"
@freeze_time("2024-07-23 00:00")
def test_date_relative_uses_day_and_month_for_date_next_year():
timestamp = timezone.now() + timedelta(days=400)
assert date_relative(timestamp) == "August 27, 2025"
| 3,266
|
Python
|
.py
| 64
| 47.40625
| 70
| 0.731207
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,913
|
apps.py
|
rafalp_Misago/misago/postgres/apps.py
|
from django.apps import AppConfig
class MisagoPostgresConfig(AppConfig):
name = "misago.postgres"
label = "misago_postgres"
| 134
|
Python
|
.py
| 4
| 30
| 38
| 0.78125
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,914
|
delete.py
|
rafalp_Misago/misago/postgres/delete.py
|
from typing import Type
from django.db.models import Model
from .execute import execute_rowcount
def delete_one(obj: Model) -> int:
"""Deletes an object from the database, bypassing all Django ORM logic.
Returns a number of deleted rows.
"""
table = obj._meta.db_table
pkey = obj._meta.pk.column
return execute_rowcount(f'DELETE FROM "{table}" WHERE "{pkey}" = %s;', [obj.pk])
def delete_all(model: Type[Model], **where):
"""Deletes multiple rows from the database, bypassing all Django ORM logic.
Requires at least ONE kwarg with a name of model field to use in the delete:
`delete_all(User, group_id=9)` executes the
`DELETE FROM "misago_users_user" WHERE "group_id" = 9;` query.
`delete_all(User, pk=[1, 3, 4])` executes the
`DELETE FROM "misago_users_user" WHERE "id" IN (1, 3, 4);` query.
Multiple kwargs are joined with the "AND" keyword:
`delete_all(User, group_id=9, is_misago_admin=False)` will execute the
`DELETE FROM "misago_users_user" WHERE "group_id" = 9 AND "is_misago_admin" = FALSE;`
query.
Returns a number of deleted rows.
"""
if not where:
raise ValueError("At least one 'WHERE' clause is required.")
fields = []
params = []
for field, value in where.items():
column = model._meta.get_field(field).column
if isinstance(value, list):
in_clause = ", ".join(["%s"] * len(value))
fields.append(f'"{column}" IN ({in_clause})')
params += value
else:
fields.append(f'"{column}" = %s')
params.append(value)
table = model._meta.db_table
where_joined = " AND ".join(fields)
return execute_rowcount(f'DELETE FROM "{table}" WHERE {where_joined};', params)
| 1,773
|
Python
|
.py
| 39
| 39.128205
| 89
| 0.647264
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,915
|
execute.py
|
rafalp_Misago/misago/postgres/execute.py
|
from typing import Any
from django.db import connection
def execute_fetch_all(query: str, params: dict | list | None = None) -> list[tuple]:
"""Executes a raw query and returns all rows."""
with connection.cursor() as cursor:
cursor.execute(query, params)
return cursor.fetchall()
def execute_fetch_one(query: str, params: dict | list | None = None) -> tuple:
"""Executes a raw query and returns one row."""
with connection.cursor() as cursor:
cursor.execute(query, params)
return cursor.fetchone()
def execute_rowcount(query: str, params: dict | list | None = None) -> int:
"""Executes a raw query and returns a number of affected rows."""
with connection.cursor() as cursor:
cursor.execute(query, params)
return cursor.rowcount
| 809
|
Python
|
.py
| 17
| 41.941176
| 84
| 0.686624
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,916
|
test_execute.py
|
rafalp_Misago/misago/postgres/tests/test_execute.py
|
from ..execute import execute_fetch_all, execute_fetch_one
def test_query_is_executed_and_all_results_are_returned(user, other_user):
results = execute_fetch_all("SELECT id FROM misago_users_user;")
assert len(results) == 2
results_flat = [row[0] for row in results]
assert user.id in results_flat
assert other_user.id in results_flat
def test_query_is_executed_and_one_result_is_returned(admin, user, other_user):
results = execute_fetch_one("SELECT COUNT(*) FROM misago_users_user;")
assert results == (3,)
| 542
|
Python
|
.py
| 10
| 49.9
| 79
| 0.73055
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,917
|
test_delete.py
|
rafalp_Misago/misago/postgres/tests/test_delete.py
|
import pytest
from django.core.exceptions import ObjectDoesNotExist
from ...cache.models import CacheVersion
from ..delete import delete_all, delete_one
def test_one_object_is_deleted_from_database(db):
cache_version = CacheVersion.objects.create(cache="test", version="test")
result = delete_one(cache_version)
assert result == 1
with pytest.raises(ObjectDoesNotExist):
cache_version.refresh_from_db()
def test_one_object_is_deleted_from_database(db):
cache_version = CacheVersion.objects.create(cache="test", version="test")
result = delete_one(cache_version)
assert result == 1
with pytest.raises(ObjectDoesNotExist):
cache_version.refresh_from_db()
def test_multiple_objects_are_deleted_from_database_using_column_equals(db):
cache_version_1 = CacheVersion.objects.create(cache="test_1", version="test")
cache_version_2 = CacheVersion.objects.create(cache="test_2", version="test")
cache_version_3 = CacheVersion.objects.create(cache="test_3", version="other")
result = delete_all(CacheVersion, version="test")
assert result == 2
with pytest.raises(ObjectDoesNotExist):
cache_version_1.refresh_from_db()
with pytest.raises(ObjectDoesNotExist):
cache_version_2.refresh_from_db()
cache_version_3.refresh_from_db()
def test_multiple_objects_are_deleted_from_database_using_column_in(db):
cache_version_1 = CacheVersion.objects.create(cache="test_1", version="test")
cache_version_2 = CacheVersion.objects.create(cache="test_2", version="test")
cache_version_3 = CacheVersion.objects.create(cache="test_3", version="other")
result = delete_all(CacheVersion, cache=["test_1", "test_2"])
assert result == 2
with pytest.raises(ObjectDoesNotExist):
cache_version_1.refresh_from_db()
with pytest.raises(ObjectDoesNotExist):
cache_version_2.refresh_from_db()
cache_version_3.refresh_from_db()
def test_multiple_objects_are_deleted_from_database_using_column_and_column(db):
cache_version_1 = CacheVersion.objects.create(cache="test_1", version="delete")
cache_version_2 = CacheVersion.objects.create(cache="test_2", version="test")
cache_version_3 = CacheVersion.objects.create(cache="test_3", version="other")
result = delete_all(CacheVersion, cache=["test_1", "test_2"], version="delete")
assert result == 1
with pytest.raises(ObjectDoesNotExist):
cache_version_1.refresh_from_db()
cache_version_2.refresh_from_db()
cache_version_3.refresh_from_db()
def test_delete_all_raises_value_error_if_where_clause_is_not_set(db):
cache_version_1 = CacheVersion.objects.create(cache="test_1", version="delete")
cache_version_2 = CacheVersion.objects.create(cache="test_2", version="test")
cache_version_3 = CacheVersion.objects.create(cache="test_3", version="other")
with pytest.raises(ValueError):
delete_all(CacheVersion)
# No rows have been deleted
cache_version_1.refresh_from_db()
cache_version_2.refresh_from_db()
cache_version_3.refresh_from_db()
| 3,093
|
Python
|
.py
| 58
| 47.982759
| 83
| 0.731626
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,918
|
urls.py
|
rafalp_Misago/misago/auth/urls.py
|
from django.urls import path
from .views import login
urlpatterns = [path("login/", login, name="login")]
| 109
|
Python
|
.py
| 3
| 34.333333
| 51
| 0.757282
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,919
|
apps.py
|
rafalp_Misago/misago/auth/apps.py
|
from django.apps import AppConfig
class MisagoAuthConfig(AppConfig):
name = "misago.auth"
label = "misago_auth"
verbose_name = "Misago Auth"
| 155
|
Python
|
.py
| 5
| 27.2
| 34
| 0.736486
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,920
|
loginurl.py
|
rafalp_Misago/misago/auth/loginurl.py
|
from django.conf import settings
from django.urls import NoReverseMatch, reverse
def get_login_url():
try:
return reverse(settings.LOGIN_URL)
except NoReverseMatch:
return settings.LOGIN_URL
| 217
|
Python
|
.py
| 7
| 26.285714
| 47
| 0.754808
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,921
|
nextpage.py
|
rafalp_Misago/misago/auth/nextpage.py
|
from urllib.parse import urlparse
from django.http import HttpRequest
from django.urls import Resolver404, resolve
from django.utils.http import url_has_allowed_host_and_scheme
NEXT_PAGE = "next"
def get_next_page_url(request: HttpRequest) -> str | None:
redirect_to = request.POST.get(NEXT_PAGE, request.GET.get(NEXT_PAGE))
if redirect_to:
return clean_next_page_url(request, redirect_to)
return None
def clean_next_page_url(request: HttpRequest, redirect_to: str) -> str | None:
url_is_safe = url_has_allowed_host_and_scheme(
url=redirect_to,
allowed_hosts=request.get_host(),
require_https=request.is_secure(),
)
if not url_is_safe:
return None
path, query = parse_redirect_url(redirect_to)
if not path:
return None
try:
resolve(path)
return build_redirect_url(path, query)
except Resolver404:
return None
def parse_redirect_url(redirect_to: str) -> tuple[str, str] | None:
try:
parsed = urlparse(redirect_to)
return parsed.path, parsed.query
except ValueError:
return None
def build_redirect_url(path: str, query: str) -> str:
redirect_url = path
if query:
redirect_url += f"?{query}"
return redirect_url
| 1,286
|
Python
|
.py
| 37
| 28.972973
| 78
| 0.683657
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,922
|
decorators.py
|
rafalp_Misago/misago/auth/decorators.py
|
from functools import wraps
from typing import Callable
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext
from .views import is_misago_login_page_disabled, login
def login_required(f_or_message: Callable | str):
if isinstance(f_or_message, str):
def _outer_login_required_decorator(f):
return _create_login_required_decorator(f, f_or_message)
return _outer_login_required_decorator
return _create_login_required_decorator(f_or_message)
def _create_login_required_decorator(f: Callable, message: str | None = None):
@wraps(f)
def login_required_decorator(request, *args, **kwargs):
login_message = message or pgettext(
"login required decorator", "Sign in to continue"
)
if not request.user.is_authenticated:
if request.is_htmx or is_misago_login_page_disabled():
raise PermissionDenied(login_message)
return login(
request,
message=login_message,
next=request.get_full_path_info(),
)
return f(request, *args, **kwargs)
return login_required_decorator
| 1,204
|
Python
|
.py
| 27
| 36
| 78
| 0.676976
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,923
|
views.py
|
rafalp_Misago/misago/auth/views.py
|
from django.conf import settings
from django.contrib import auth
from django.http import Http404, HttpRequest, HttpResponse
from django.shortcuts import redirect, render
from django.urls import reverse
from django.utils.decorators import method_decorator
from django.views import View
from django.views.decorators.cache import never_cache
from django.views.decorators.debug import sensitive_post_parameters
from ..core.exceptions import Banned
from ..users.forms.auth import AuthenticationForm
from .nextpage import clean_next_page_url, get_next_page_url
from .loginurl import get_login_url
class LoginView(View):
template_name: str = "misago/auth/login_page.html"
form_type = AuthenticationForm
@method_decorator(sensitive_post_parameters())
@method_decorator(never_cache)
def dispatch(self, request: HttpRequest, **kwargs) -> HttpResponse:
if self.is_view_disabled():
raise Http404()
if request.user.is_authenticated:
return self.get_next_page_redirect(request, kwargs)
if request.settings.enable_oauth2_client:
return delegated_login(request, message=kwargs.get("message"))
return super().dispatch(request, **kwargs)
def get(self, request: HttpRequest, **kwargs) -> HttpResponse:
form = self.form_type(request=request)
return self.render(request, form, kwargs)
def post(self, request: HttpRequest, **kwargs) -> HttpResponse:
form = self.form_type(request.POST, request=request)
if form.is_valid():
return self.handle_valid_form(request, form, kwargs)
if form.user_ban:
raise Banned(form.user_ban)
print(form.non_field_errors)
return self.render(request, form, kwargs)
def handle_valid_form(
self, request: HttpRequest, form: AuthenticationForm, kwargs: dict
) -> HttpResponse:
user = form.user_cache
auth.login(request, user)
return self.get_next_page_redirect(request, kwargs)
def get_next_page_redirect(
self, request: HttpRequest, kwargs: dict
) -> HttpResponse:
if kwargs.get("next"):
if next_page_url := clean_next_page_url(request, kwargs["next"]):
return redirect(next_page_url)
elif next_page_url := get_next_page_url(request):
return redirect(next_page_url)
return redirect(settings.LOGIN_REDIRECT_URL)
def render(
self, request: HttpRequest, form: AuthenticationForm, kwargs: dict
) -> HttpResponse:
context = {
"form": form,
"social_login": list(request.socialauth.values()),
}
if kwargs.get("message"):
context["form_header"] = kwargs["message"]
if "next" not in kwargs:
context["next_page_url"] = get_next_page_url(request)
return render(request, self.template_name, context)
def is_view_disabled(self) -> bool:
return is_misago_login_page_disabled()
login = LoginView.as_view()
def delegated_login(request: HttpRequest, *, message: str | None = None):
return render(request, "misago/auth/delegated_page.html", {"form_header": message})
def is_misago_login_page_disabled() -> bool:
return get_login_url() != reverse("misago:login")
| 3,293
|
Python
|
.py
| 71
| 39.112676
| 87
| 0.688458
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,924
|
test_get_login_url.py
|
rafalp_Misago/misago/auth/tests/test_get_login_url.py
|
from django.urls import reverse
from django.test import override_settings
from ..loginurl import get_login_url
@override_settings(LOGIN_URL="misago:login")
def test_get_login_url_returns_reversed_url():
assert get_login_url() == reverse("misago:login")
@override_settings(LOGIN_URL="/other/login/")
def test_get_login_url_returns_absolute_url():
assert get_login_url() == "/other/login/"
| 401
|
Python
|
.py
| 9
| 42.111111
| 53
| 0.762274
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,925
|
test_login_required_decorator.py
|
rafalp_Misago/misago/auth/tests/test_login_required_decorator.py
|
from django.test import override_settings
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...test import assert_contains, assert_not_contains
def test_require_login_decorator_displays_login_form_to_guests(db, client):
response = client.get(reverse("misago:account-preferences"))
assert_contains(response, "page-login")
assert_contains(response, "Sign in")
def test_require_login_decorator_displays_view_to_authenticated(user_client):
response = user_client.get(reverse("misago:account-preferences"))
assert_not_contains(response, "page-login")
def test_require_login_decorator_authenticates_user_by_username(
client, user, user_password
):
response = client.post(
reverse("misago:account-preferences"),
{"username": user.username, "password": user_password},
)
assert response.status_code == 302
assert response["location"] == reverse("misago:account-preferences")
@override_settings(LOGIN_URL="/other/login/")
def test_require_login_decorator_displays_permisison_denied_if_custom_login_page_is_enabled(
db, client
):
response = client.get(reverse("misago:account-preferences"))
assert response.status_code == 403
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="OAuth2",
)
def test_require_login_decorator_displays_delegated_login_form_if_auth_is_delegated(
db, client
):
response = client.get(reverse("misago:account-preferences"))
assert_contains(response, "page-login")
assert_contains(response, "Sign in")
assert_contains(response, "Sign in with OAuth2")
| 1,630
|
Python
|
.py
| 37
| 40.162162
| 92
| 0.757269
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,926
|
test_login_view.py
|
rafalp_Misago/misago/auth/tests/test_login_view.py
|
from urllib.parse import quote_plus
from django.test import override_settings
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...test import assert_contains, assert_not_contains
from ...users.models import Ban
def test_login_view_displays_login_form_to_guests(db, client):
response = client.get(reverse("misago:login"))
assert_contains(response, "page-login")
assert_contains(response, "Sign in")
def test_login_view_authenticates_user_by_username(client, user, user_password):
response = client.post(
reverse("misago:login"),
{"username": user.username, "password": user_password},
)
assert response.status_code == 302
response = client.get(reverse("misago:index"))
assert_contains(response, user.username)
def test_login_view_authenticates_user_by_email(client, user, user_password):
response = client.post(
reverse("misago:login"),
{"username": user.email, "password": user_password},
)
assert response.status_code == 302
response = client.get(reverse("misago:index"))
assert_contains(response, user.username)
def test_login_view_redirects_authenticated_user_by_post_value(
client, user, user_password
):
response = client.post(
reverse("misago:login"),
{
"username": user.email,
"password": user_password,
"next": reverse("misago:account-preferences"),
},
)
assert response.status_code == 302
assert response["location"] == reverse("misago:account-preferences")
response = client.get(reverse("misago:index"))
assert_contains(response, user.username)
def test_login_view_redirects_authenticated_user_by_query_parameter(
client, user, user_password
):
response = client.post(
reverse("misago:login")
+ "?next="
+ quote_plus(reverse("misago:account-preferences")),
{
"username": user.email,
"password": user_password,
},
)
assert response.status_code == 302
assert response["location"] == reverse("misago:account-preferences")
response = client.get(reverse("misago:index"))
assert_contains(response, user.username)
def test_login_view_redirects_already_authenticated_user(user_client):
response = user_client.post(reverse("misago:login"))
assert response.status_code == 302
assert response["location"] == reverse("misago:index")
def test_login_view_redirects_already_authenticated_user_by_post_value(user_client):
response = user_client.post(
reverse("misago:login"),
{
"next": reverse("misago:account-preferences"),
},
)
assert response.status_code == 302
assert response["location"] == reverse("misago:account-preferences")
def test_login_view_redirects_already_authenticated_user_by_query_parameter(
user_client,
):
response = user_client.get(
reverse("misago:login")
+ "?next="
+ quote_plus(reverse("misago:account-preferences"))
)
assert response.status_code == 302
assert response["location"] == reverse("misago:account-preferences")
def test_login_view_displays_social_auth_buttons(
social_auth_github, social_auth_facebook, client
):
response = client.get(reverse("misago:login"))
assert_contains(response, "page-login")
assert_contains(response, "Sign in")
assert_contains(response, "Sign in with GitHub")
assert_contains(response, "Sign in with Facebook")
assert_not_contains(response, "Sign in with X")
@override_settings(LOGIN_URL="/other/login/")
def test_login_view_is_not_available_if_custom_login_url_is_set(db, client):
response = client.get(reverse("misago:login"))
assert response.status_code == 404
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="OAuth2",
)
def test_login_view_displays_delegated_page_if_auth_is_delegated(db, client):
response = client.get(reverse("misago:login"))
assert_contains(response, "page-login")
assert_contains(response, "Sign in")
assert_contains(response, "Sign in with OAuth2")
def test_login_view_displays_error_if_username_is_missing(db, client):
response = client.post(reverse("misago:login"), {"password": "password"})
assert_contains(response, "Fill out all fields.")
def test_login_view_displays_error_if_password_is_missing(db, client):
response = client.post(reverse("misago:login"), {"username": "username"})
assert_contains(response, "Fill out all fields.")
def test_login_view_displays_error_if_username_and_password_is_missing(db, client):
response = client.post(reverse("misago:login"))
assert_contains(response, "Fill out all fields.")
def test_login_view_displays_error_if_username_is_invalid(db, client):
response = client.post(
reverse("misago:login"),
{"username": "invalid", "password": "invalid"},
)
assert_contains(response, "Login or password is incorrect.")
def test_login_view_displays_error_if_password_is_invalid(client, user):
response = client.post(
reverse("misago:login"),
{"username": user.username, "password": "invalid"},
)
assert_contains(response, "Login or password is incorrect.")
def test_login_view_displays_error_if_user_account_is_deactivated(
client, user, user_password
):
user.is_active = False
user.save()
response = client.post(
reverse("misago:login"),
{"username": user.username, "password": user_password},
)
assert_contains(response, "Login or password is incorrect.")
def test_login_view_displays_banned_page_to_banned_users(client, user, user_password):
ban = Ban.objects.create(
banned_value=user.username,
check_type=Ban.USERNAME,
user_message="This is a test ban.",
)
response = client.post(
reverse("misago:login"),
{
"username": user.email,
"password": user_password,
},
)
assert_contains(response, ban.user_message, status_code=403)
def test_login_view_excludes_root_misago_admins_from_ban_check(
client, root_admin, user_password
):
Ban.objects.create(
banned_value=root_admin.username,
check_type=Ban.USERNAME,
user_message="This is a test ban.",
)
response = client.post(
reverse("misago:login"),
{
"username": root_admin.email,
"password": user_password,
},
)
response = client.get(reverse("misago:index"))
assert_contains(response, root_admin.username)
def test_login_view_excludes_misago_admins_from_ban_check(
client, secondary_admin, user_password
):
Ban.objects.create(
banned_value=secondary_admin.username,
check_type=Ban.USERNAME,
user_message="This is a test ban.",
)
response = client.post(
reverse("misago:login"),
{
"username": secondary_admin.email,
"password": user_password,
},
)
response = client.get(reverse("misago:index"))
assert_contains(response, secondary_admin.username)
def test_login_view_displays_error_if_user_needs_admin_activation(
client, user, user_password
):
user.requires_activation = user.ACTIVATION_ADMIN
user.save()
response = client.post(
reverse("misago:login"),
{"username": user.username, "password": user_password},
)
assert_contains(response, "A site administrator has to activate your account")
def test_login_view_displays_error_if_user_needs_user_activation(
client, user, user_password
):
user.requires_activation = user.ACTIVATION_USER
user.save()
response = client.post(
reverse("misago:login"),
{"username": user.username, "password": user_password},
)
assert_contains(response, "You have to activate your account")
| 7,926
|
Python
|
.py
| 201
| 33.547264
| 86
| 0.688666
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,927
|
test_next_page_url.py
|
rafalp_Misago/misago/auth/tests/test_next_page_url.py
|
from urllib.parse import quote_plus
from django.urls import reverse
from ..nextpage import clean_next_page_url, get_next_page_url
def test_get_next_page_url_returns_clean_url_from_post(rf):
request = rf.get(
reverse("misago:login"),
{"next": reverse("misago:account-preferences")},
)
assert get_next_page_url(request) == reverse("misago:account-preferences")
def test_get_next_page_url_returns_clean_url_from_get(rf):
request = rf.get(
reverse("misago:login")
+ "?next="
+ quote_plus(reverse("misago:account-preferences")),
)
assert get_next_page_url(request) == reverse("misago:account-preferences")
def test_get_next_page_url_returns_clean_url_from_post_before_get(rf):
request = rf.get(
reverse("misago:login") + "?next=" + quote_plus(reverse("misago:index")),
{"next": reverse("misago:account-preferences")},
)
assert get_next_page_url(request) == reverse("misago:account-preferences")
def test_clean_next_page_url_returns_valid_relative_misago_url(rf):
request = rf.get(reverse("misago:login"))
next_page_url = clean_next_page_url(request, reverse("misago:account-preferences"))
assert next_page_url == reverse("misago:account-preferences")
def test_clean_next_page_url_returns_none_if_relative_url_has_no_match(rf):
request = rf.get(reverse("misago:login"))
next_page_url = clean_next_page_url(request, "/wp-admin.php")
assert next_page_url is None
def test_clean_next_page_url_returns_valid_absolute_url(rf):
request = rf.get(reverse("misago:login"))
next_page_url = clean_next_page_url(request, "http://testserver/account/")
assert next_page_url == "/account/"
def test_clean_next_page_url_returns_valid_absolute_url_with_querystring(rf):
request = rf.get(reverse("misago:login"))
next_page_url = clean_next_page_url(request, "http://testserver/account/?query=1")
assert next_page_url == "/account/?query=1"
def test_clean_next_page_url_returns_none_for_absolute_url_with_invalid_host(rf):
request = rf.get(reverse("misago:login"))
next_page_url = clean_next_page_url(request, "http://example.com/account/?query=1")
assert next_page_url is None
def test_clean_next_page_url_returns_none_for_absolute_url_with_invalid_path(rf):
request = rf.get(reverse("misago:login"))
next_page_url = clean_next_page_url(request, "http://testserver/wp-admin.php")
assert next_page_url is None
| 2,472
|
Python
|
.py
| 46
| 48.673913
| 87
| 0.711194
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,928
|
rest_permissions.py
|
rafalp_Misago/misago/core/rest_permissions.py
|
from django.core.exceptions import PermissionDenied
from django.utils.translation import pgettext
from rest_framework.permissions import SAFE_METHODS, BasePermission
class IsAuthenticatedOrReadOnly(BasePermission):
def has_permission(self, request, view):
if request.user.is_anonymous and request.method not in SAFE_METHODS:
raise PermissionDenied(
pgettext("api", "This action is not available to guests.")
)
return True
| 485
|
Python
|
.py
| 10
| 41.2
| 76
| 0.741525
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,929
|
viewmodel.py
|
rafalp_Misago/misago/core/viewmodel.py
|
class ViewModel:
def __getattr__(self, name):
return getattr(self._model, name)
def unwrap(self):
return self._model
| 142
|
Python
|
.py
| 5
| 22.4
| 41
| 0.632353
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,930
|
apirouter.py
|
rafalp_Misago/misago/core/apirouter.py
|
from rest_framework.routers import DefaultRouter, DynamicRoute, Route
class MisagoApiRouter(DefaultRouter):
include_root_view = False
include_format_suffixes = False
routes = [
# List route.
Route(
url=r"^{prefix}{trailing_slash}$",
mapping={"get": "list", "post": "create"},
name="{basename}-list",
initkwargs={"suffix": "List"},
detail=False,
),
# Dynamically generated list routes.
# Generated using @list_route decorator
# on methods of the viewset.
DynamicRoute(
url=r"^{prefix}/{url_path}{trailing_slash}$",
name="{basename}-{url_name}",
initkwargs={},
detail=False,
),
# Detail route.
Route(
url=r"^{prefix}/{lookup}{trailing_slash}$",
mapping={
"get": "retrieve",
"put": "update",
"patch": "partial_update",
"delete": "destroy",
},
name="{basename}-detail",
initkwargs={"suffix": "Instance"},
detail=True,
),
# Dynamically generated detail routes.
# Generated using @detail_route decorator on methods of the viewset.
DynamicRoute(
url=r"^{prefix}/{lookup}/{url_path}{trailing_slash}$",
name="{basename}-{url_name}",
initkwargs={},
detail=True,
),
]
| 1,488
|
Python
|
.py
| 44
| 23.022727
| 76
| 0.51839
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,931
|
serializers.py
|
rafalp_Misago/misago/core/serializers.py
|
class MutableFields:
@classmethod
def subset_fields(cls, *fields):
fields_in_name = [f.title().replace("_", "") for f in fields]
name = "%s%sSubset" % (cls.__name__, "".join(fields_in_name)[:100])
class Meta(cls.Meta):
pass
Meta.fields = list(fields)
return type(name, (cls,), {"Meta": Meta})
@classmethod
def exclude_fields(cls, *fields):
final_fields = []
for field in cls.Meta.fields:
if field not in fields:
final_fields.append(field)
fields_in_name = [f.title().replace("_", "") for f in final_fields]
name = "%s%sSubset" % (cls.__name__, "".join(fields_in_name)[:100])
class Meta(cls.Meta):
pass
Meta.fields = list(final_fields)
return type(name, (cls,), {"Meta": Meta})
@classmethod
def extend_fields(cls, *fields):
final_fields = list(cls.Meta.fields)
for field in fields:
if field not in final_fields:
final_fields.append(field)
fields_in_name = [f.title().replace("_", "") for f in final_fields]
name = "%s%sSubset" % (cls.__name__, "".join(fields_in_name)[:100])
class Meta(cls.Meta):
pass
Meta.fields = list(final_fields)
return type(name, (cls,), {"Meta": Meta})
| 1,357
|
Python
|
.py
| 33
| 31.606061
| 75
| 0.554539
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,932
|
exceptionhandler.py
|
rafalp_Misago/misago/core/exceptionhandler.py
|
from urllib.parse import urlencode
from django.core.exceptions import PermissionDenied
from django.http import (
Http404,
HttpResponse,
HttpResponsePermanentRedirect,
JsonResponse,
)
from django.urls import reverse
from rest_framework.views import exception_handler as rest_exception_handler
from social_core.exceptions import SocialAuthBaseException
from social_core.utils import social_logger
from . import errorpages
from .exceptions import AjaxError, Banned, ExplicitFirstPage, OutdatedSlug
HANDLED_EXCEPTIONS = (
AjaxError,
Banned,
ExplicitFirstPage,
Http404,
OutdatedSlug,
PermissionDenied,
SocialAuthBaseException,
)
def is_misago_exception(exception):
return isinstance(exception, HANDLED_EXCEPTIONS)
def handle_ajax_error(request, exception):
json = {"is_error": 1, "message": str(exception.message)}
return JsonResponse(json, status=exception.code)
def handle_banned_exception(request, exception):
return errorpages.banned(request, exception)
def handle_explicit_first_page_exception(request, exception):
matched_url = request.resolver_match.url_name
if request.resolver_match.namespace:
matched_url = "%s:%s" % (request.resolver_match.namespace, matched_url)
url_kwargs = request.resolver_match.kwargs
del url_kwargs["page"]
new_url = reverse(matched_url, kwargs=url_kwargs)
return HttpResponsePermanentRedirect(new_url)
def handle_http404_exception(request, exception):
return errorpages.page_not_found(request, exception)
def handle_outdated_slug_exception(request, exception):
view_name = request.resolver_match.view_name
model = exception.args[0]
url_kwargs = request.resolver_match.kwargs
url_kwargs["slug"] = model.slug
new_url = reverse(view_name, kwargs=url_kwargs)
if request.GET:
new_url += "?" + urlencode(request.GET)
return HttpResponsePermanentRedirect(new_url)
def handle_permission_denied_exception(request, exception):
return errorpages.permission_denied(request, exception)
def handle_social_auth_exception(request, exception):
social_logger.error(exception, exc_info=exception)
return errorpages.social_auth_failed(request, exception)
EXCEPTION_HANDLERS = [
(AjaxError, handle_ajax_error),
(Banned, handle_banned_exception),
(Http404, handle_http404_exception),
(ExplicitFirstPage, handle_explicit_first_page_exception),
(OutdatedSlug, handle_outdated_slug_exception),
(PermissionDenied, handle_permission_denied_exception),
(SocialAuthBaseException, handle_social_auth_exception),
]
def get_exception_handler(exception):
for exception_type, handler in EXCEPTION_HANDLERS:
if isinstance(exception, exception_type):
return handler
raise ValueError("%s is not a Misago exception" % exception.__class__.__name__)
def handle_misago_exception(request, exception):
if request.is_htmx and isinstance(exception, (Http404, PermissionDenied)):
return handle_htmx_exception(exception)
handler = get_exception_handler(exception)
return handler(request, exception)
def handle_htmx_exception(exception: Http404 | PermissionDenied) -> HttpResponse:
status = status = 404 if isinstance(exception, Http404) else 403
if not exception.args:
return HttpResponse(status=status)
return JsonResponse({"error": str(exception.args[0])}, status=status)
def handle_api_exception(exception, context):
response = rest_exception_handler(exception, context)
if response:
if isinstance(exception, Banned):
response.data["ban"] = exception.ban.get_serialized_message()
elif isinstance(exception, PermissionDenied):
try:
response.data["detail"] = exception.args[0]
except IndexError:
pass
return response
| 3,877
|
Python
|
.py
| 89
| 38.337079
| 83
| 0.752399
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,933
|
apipatch.py
|
rafalp_Misago/misago/core/apipatch.py
|
from django.core.exceptions import PermissionDenied
from django.db import transaction
from django.http import Http404
from rest_framework.response import Response
ALLOWED_OPS = ("add", "remove", "replace")
class InvalidAction(Exception):
pass
class ApiPatch:
def __init__(self):
self._actions = []
def add(self, path, handler):
self._actions.append({"op": "add", "path": path, "handler": handler})
def remove(self, path, handler):
self._actions.append({"op": "remove", "path": path, "handler": handler})
def replace(self, path, handler):
self._actions.append({"op": "replace", "path": path, "handler": handler})
def dispatch(self, request, target):
if not isinstance(request.data, list):
return Response(
{"detail": "PATCH request should be list of operations"}, status=400
)
detail = []
is_errored = False
patch = {"id": target.pk}
for action in request.data:
try:
self.validate_action(action)
self.dispatch_action(patch, request, target, action)
detail.append("ok")
except Http404:
is_errored = True
detail.append("NOT FOUND")
break
except (InvalidAction, PermissionDenied) as e:
is_errored = True
detail.append(e.args[0])
break
patch["detail"] = detail
if is_errored:
return Response(patch, status=400)
return Response(patch)
def dispatch_bulk(self, request, targets):
is_errored = False
result = []
for target in targets:
detail = []
patch = {"id": target.pk}
for action in request.data["ops"]:
try:
self.validate_action(action)
self.dispatch_action(patch, request, target, action)
except Http404:
is_errored = True
detail.append("NOT FOUND")
break
except (InvalidAction, PermissionDenied) as e:
is_errored = True
detail.append(e.args[0])
break
if detail:
patch["detail"] = detail
result.append(patch)
if is_errored:
return Response(result, status=400)
return Response(result)
def validate_action(self, action):
if not action.get("op"):
raise InvalidAction("undefined op")
if action.get("op") not in ALLOWED_OPS:
raise InvalidAction('"%s" op is unsupported' % action.get("op"))
if not action.get("path"):
raise InvalidAction('"%s" op has to specify path' % action.get("op"))
if "value" not in action:
raise InvalidAction('"%s" op has to specify value' % action.get("op"))
def dispatch_action(self, patch, request, target, action):
for handler in self._actions:
if action["op"] == handler["op"] and action["path"] == handler["path"]:
with transaction.atomic():
patch.update(handler["handler"](request, target, action["value"]))
| 3,288
|
Python
|
.py
| 79
| 29.772152
| 86
| 0.557403
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,934
|
page.py
|
rafalp_Misago/misago/core/page.py
|
class Page:
"""
Misago page utility
Allows for adding custom views to "sectioned" pages like
User Control Panel, Users List or Threads Lists
"""
def __init__(self, name):
self._finalized = False
self.name = name
self._unsorted_list = []
self._sorted_list = []
def assert_is_finalized(self):
if not self._finalized:
self._finalized = True
self._finalize()
def _finalize(self):
iterations = 0
while self._unsorted_list:
iterations += 1
if iterations > 512:
message = (
"%s page hierarchy is invalid or too complex to resolve. "
"Sections left: %s"
)
raise ValueError(message % self._unsorted_list)
for index, section in enumerate(self._unsorted_list):
if section["after"]:
section_added = self._insert_section(
section, after=section["after"]
)
elif section["before"]:
section_added = self._insert_section(
section, before=section["before"]
)
else:
section_added = self._insert_section(section)
if section_added:
del self._unsorted_list[index]
break
def _insert_section(self, inserted_section, after=None, before=None):
if after:
new_sorted_list = []
for section in self._sorted_list:
new_sorted_list.append(section)
if section["link"] == after:
new_sorted_list.append(inserted_section)
self._sorted_list = new_sorted_list
return True
return False
if before:
new_sorted_list = []
for section in self._sorted_list:
if section["link"] == before:
new_sorted_list.append(inserted_section)
new_sorted_list.append(section)
self._sorted_list = new_sorted_list
return True
new_sorted_list.append(section)
return False
self._sorted_list.append(inserted_section)
return True
def add_section(
self,
link,
after=None,
before=None,
visible_if=None,
get_metadata=None,
**kwargs
):
if self._finalized:
message = (
"%s page was initialized already and no longer accepts new sections"
)
raise RuntimeError(message % self.name)
if after and before:
raise ValueError("after and before arguments are exclusive")
kwargs.update(
{
"link": link,
"after": after,
"before": before,
"visible_if": visible_if,
"get_metadata": get_metadata,
}
)
self._unsorted_list.append(kwargs)
def _active_link_name(self, request) -> str | None:
if not request.resolver_match:
return None
namespace = request.resolver_match.namespace
url_name = request.resolver_match.url_name
if namespace:
active_link = "%s:%s" % (namespace, url_name)
else:
active_link = url_name
return active_link
def get_sections(self, request, *args):
self.assert_is_finalized()
active_link = self._active_link_name(request)
visible_sections = []
for section_definition in self._sorted_list:
section = section_definition.copy()
is_visible = True
if section["visible_if"]:
is_visible = section["visible_if"](request, *args)
if is_visible:
if section["get_metadata"]:
section["metadata"] = section["get_metadata"](request, *args)
if active_link:
section["is_active"] = active_link.startswith(section["link"])
else:
section["is_active"] = None
visible_sections.append(section)
return visible_sections
def get_default_link(self):
self.assert_is_finalized()
return self._sorted_list[0]["link"]
| 4,451
|
Python
|
.py
| 118
| 24.576271
| 84
| 0.521104
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,935
|
slugify.py
|
rafalp_Misago/misago/core/slugify.py
|
from django.template.defaultfilters import slugify as django_slugify
from unidecode import unidecode
def default(string):
string = str(string)
string = unidecode(string)
return django_slugify(string.replace("_", " ").strip())
| 240
|
Python
|
.py
| 6
| 36.666667
| 68
| 0.762931
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,936
|
apps.py
|
rafalp_Misago/misago/core/apps.py
|
from django.apps import AppConfig
class MisagoCoreConfig(AppConfig):
name = "misago.core"
label = "misago_core"
verbose_name = "Misago Core"
| 155
|
Python
|
.py
| 5
| 27.2
| 34
| 0.736486
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,937
|
context_processors.py
|
rafalp_Misago/misago/core/context_processors.py
|
from django.utils.translation import get_language
from .. import __version__
from ..hooks import context_processors as context_processors_hooks
from .momentjs import get_locale_url
def misago_version(request):
return {"MISAGO_VERSION": __version__}
def request_path(request):
return {"request_path": request.path}
def current_link(request):
if not request.resolver_match or request.frontend_context.get("CURRENT_LINK"):
return {}
url_name = request.resolver_match.url_name
if request.resolver_match.namespaces:
namespaces = ":".join(request.resolver_match.namespaces)
link_name = "%s:%s" % (namespaces, url_name)
else:
link_name = url_name
request.frontend_context.update({"CURRENT_LINK": link_name})
return {}
def momentjs_locale(request):
return {"MOMENTJS_LOCALE_URL": get_locale_url(get_language())}
def frontend_context(request):
if request.include_frontend_context:
return {"frontend_context": request.frontend_context}
return {}
def hooks(request):
context = {}
for hook in context_processors_hooks:
context.update(hook(request))
return context
| 1,172
|
Python
|
.py
| 30
| 34.066667
| 82
| 0.717584
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,938
|
cursorpagination.py
|
rafalp_Misago/misago/core/cursorpagination.py
|
from django.core.paginator import EmptyPage, InvalidPage
def get_page(queryset, order_by, per_page, start=0):
if start < 0:
raise InvalidPage()
object_list = list(_slice_queryset(queryset, order_by, per_page, start))
if start and not object_list:
raise EmptyPage()
next_cursor = None
if len(object_list) > per_page:
next_slice_first_item = object_list.pop(-1)
attr_name = order_by.lstrip("-")
next_cursor = getattr(next_slice_first_item, attr_name)
return CursorPage(start, object_list, next_cursor)
def _slice_queryset(queryset, order_by, per_page, start):
page_len = int(per_page) + 1
if start:
if order_by.startswith("-"):
filter_name = "%s__lte" % order_by[1:]
else:
filter_name = "%s__gte" % order_by
return queryset.filter(**{filter_name: start})[:page_len]
return queryset[:page_len]
class CursorPage:
def __init__(self, start, object_list, next_=None):
self.start = start or 0
self.first = self.start == 0
self.object_list = object_list
self.next = next_
def __len__(self):
return len(self.object_list)
def has_next(self):
return bool(self.next)
| 1,249
|
Python
|
.py
| 32
| 31.9375
| 76
| 0.628524
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,939
|
utils.py
|
rafalp_Misago/misago/core/utils.py
|
import hashlib
from datetime import datetime, timedelta
from django.conf import settings
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.urls import resolve, reverse
from django.utils import html, timezone
from django.utils.encoding import force_str
from django.utils.functional import Promise
from django.utils.module_loading import import_string
MISAGO_SLUGIFY = getattr(settings, "MISAGO_SLUGIFY", "misago.core.slugify.default")
slugify = import_string(MISAGO_SLUGIFY)
def format_plaintext_for_html(string):
return html.linebreaks(html.urlize(html.escape(string)))
def encode_json_html(string):
return string.replace("<", r"\u003C")
ISO8601_FORMATS = ("%Y-%m-%dT%H:%M:%S", "%Y-%m-%dT%H:%M:%S.%f")
def parse_iso8601_string(value):
"""turns ISO 8601 string into datetime object"""
value = force_str(value, strings_only=True).rstrip("Z")
for format_str in ISO8601_FORMATS:
try:
parsed_value = datetime.strptime(value, format_str)
break
except ValueError:
try:
parsed_value = datetime.strptime(value[:-6], format_str)
break
except ValueError:
pass
else:
raise ValueError("failed to hydrate the %s timestamp" % value)
offset_str = value[-6:]
if offset_str and offset_str[0] in ("-", "+"):
tz_offset = timedelta(hours=int(offset_str[1:3]), minutes=int(offset_str[4:6]))
tz_offset = tz_offset.seconds // 60
if offset_str[0] == "-":
tz_offset *= -1
else:
tz_offset = 0
tz_correction = timezone.get_fixed_timezone(tz_offset)
return timezone.make_aware(parsed_value, tz_correction)
def hide_post_parameters(request):
"""
Mark request as having sensitive parameters
We can't use decorator because of DRF uses custom HttpRequest
that is incompatibile with Django's decorator
"""
request.sensitive_post_parameters = "__ALL__"
def clean_return_path(request):
"""return path utility that returns return path from referer or POST"""
if request.method == "POST" and "return_path" in request.POST:
return _get_return_path_from_post(request)
return _get_return_path_from_referer(request)
def _get_return_path_from_post(request):
return_path = request.POST.get("return_path")
try:
if not return_path:
raise ValueError()
if not return_path.startswith("/"):
raise ValueError()
resolve(return_path)
return return_path
except (Http404, ValueError):
return None
def _get_return_path_from_referer(request):
referer = request.META.get("HTTP_REFERER")
try:
if not referer:
raise ValueError()
if not referer.startswith(request.scheme):
raise ValueError()
referer = referer[len(request.scheme) + 3 :]
if not referer.startswith(request.META["HTTP_HOST"]):
raise ValueError()
referer = referer[len(request.META["HTTP_HOST"].rstrip("/")) :]
if not referer.startswith("/"):
raise ValueError()
resolve(referer)
return referer
except (Http404, KeyError, ValueError):
return None
def is_request_to_misago(request):
try:
return request._request_to_misago
except AttributeError:
request._request_to_misago = _is_request_path_under_misago(request)
return request._request_to_misago
def _is_request_path_under_misago(request):
# We are assuming that forum_index link is root of all Misago links
forum_index = reverse("misago:index")
path = request.path
if len(forum_index) > len(path):
return False
return path[: len(forum_index)] == forum_index
def is_referer_local(request):
referer = request.META.get("HTTP_REFERER")
if not referer:
return False
if not referer.startswith(request.scheme):
return False
referer = referer[len(request.scheme) + 3 :]
if not referer.startswith(request.META["HTTP_HOST"]):
return False
referer = referer[len(request.META["HTTP_HOST"].rstrip("/")) :]
if not referer.startswith("/"):
return False
return True
def get_exception_message(exception=None, default_message=None):
if not exception:
return default_message
try:
exception_message = exception.args[0]
if isinstance(exception_message, Promise):
return str(exception_message)
if isinstance(exception_message, str):
return exception_message
return default_message
except IndexError:
return default_message
def clean_ids_list(ids_list, error_message):
try:
return list(map(int, ids_list))
except (ValueError, TypeError):
raise PermissionDenied(error_message)
def get_host_from_address(address):
if not address:
return None
if address.lower().startswith("https://"):
address = address[8:]
if address.lower().startswith("http://"):
address = address[7:]
address = address.lstrip("/")
if "/" in address:
address = address.split("/")[0] or address
if ":" in address:
address = address.split(":")[0] or address
return address
HASH_LENGTH = 8
def get_file_hash(file_obj):
if not file_obj.size:
return "0" * HASH_LENGTH
file_hash = hashlib.md5()
for chunk in file_obj.chunks():
file_hash.update(chunk)
return file_hash.hexdigest()[:HASH_LENGTH]
| 5,567
|
Python
|
.py
| 146
| 31.39726
| 87
| 0.666667
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,940
|
__init__.py
|
rafalp_Misago/misago/core/__init__.py
|
from django.conf import settings
from django.core.checks import register, Critical
SUPPORTED_ENGINES = [
"django.db.backends.postgresql",
"django.db.backends.postgresql_psycopg2",
]
@register()
def check_db_engine(app_configs, **kwargs):
errors = []
try:
if settings.DATABASES["default"]["ENGINE"] not in SUPPORTED_ENGINES:
raise ValueError()
except (AttributeError, KeyError, ValueError):
errors.append(
Critical(msg="Misago requires PostgreSQL database.", id="misago.001")
)
return errors
| 568
|
Python
|
.py
| 17
| 27.882353
| 81
| 0.694139
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,941
|
validators.py
|
rafalp_Misago/misago/core/validators.py
|
import re
from django.core.exceptions import ValidationError
from django.core.validators import RegexValidator
from django.utils.translation import pgettext_lazy
from .utils import slugify
class validate_sluggable:
def __init__(self, error_short=None, error_long=None):
self.error_short = error_short or pgettext_lazy(
"sluggable validator", "Value has to contain alpha-numerical characters."
)
self.error_long = error_long or pgettext_lazy(
"sluggable validator", "Value is too long."
)
def __call__(self, value):
slug = slugify(value)
if not slug.replace("-", ""):
raise ValidationError(self.error_short)
if len(slug) > 255:
raise ValidationError(self.error_long)
def validate_image_square(image):
if image.width != image.height:
raise ValidationError(
pgettext_lazy("image validator", "Uploaded image is not a square.")
)
validate_color_hex = RegexValidator(
re.compile(r"^#[0-9a-f][0-9a-f][0-9a-f]([0-9a-f][0-9a-f][0-9a-f]?)$", re.I),
pgettext_lazy(
"color hex validator",
"Entered value is not a valid color in the hex format (eg. #FA8072).",
),
"invalid",
)
validate_css_name = RegexValidator(
re.compile(r"^[a-zA-Z_-]+([a-zA-Z0-9-_]+)?$"),
pgettext_lazy(
"css name validator",
"Enter a valid CSS class name that starts with a Latin letter, underscore, or a hyphen, and is followed by any combination of Latin letters, numbers, hyphens, and underscore characters.",
),
"invalid",
)
| 1,609
|
Python
|
.py
| 40
| 33.7
| 195
| 0.65617
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,942
|
middleware.py
|
rafalp_Misago/misago/core/middleware.py
|
from . import exceptionhandler
from .utils import is_request_to_misago
class ExceptionHandlerMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
return self.get_response(request)
def process_exception(self, request, exception):
request_is_to_misago = is_request_to_misago(request)
misago_can_handle_exception = exceptionhandler.is_misago_exception(exception)
if request_is_to_misago and misago_can_handle_exception:
return exceptionhandler.handle_misago_exception(request, exception)
class FrontendContextMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
request.include_frontend_context = True
request.frontend_context = {}
return self.get_response(request)
| 885
|
Python
|
.py
| 19
| 39.684211
| 85
| 0.714452
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,943
|
momentjs.py
|
rafalp_Misago/misago/core/momentjs.py
|
from ..conf import settings
MOMENT_STATIC_PATH = "misago/momentjs/%s.js"
def get_locale_url(language, *, static_path_template=None, locales=None):
locales = locales or settings.MISAGO_MOMENT_JS_LOCALES
clean_language = clean_language_name(language, locales)
if clean_language:
static_path_template = static_path_template or MOMENT_STATIC_PATH
return static_path_template % clean_language
def clean_language_name(language, locales):
# lowercase language
language = language.lower().replace("_", "-")
# first try: literal match
if language in locales:
return language
# second try: fallback to macrolanguage
language = language.split("-")[0]
if language in locales:
return language
# nothing was found
return None
| 800
|
Python
|
.py
| 20
| 34.6
| 73
| 0.715026
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,944
|
shortcuts.py
|
rafalp_Misago/misago/core/shortcuts.py
|
from django.http import Http404
from rest_framework.response import Response
def paginate(
object_list,
page,
per_page,
orphans=0,
allow_empty_first_page=True,
allow_explicit_first_page=False,
paginator=None,
):
from django.core.paginator import Paginator, EmptyPage, InvalidPage
from .exceptions import ExplicitFirstPage
if page in (1, "1") and not allow_explicit_first_page:
raise ExplicitFirstPage()
if not page:
page = 1
paginator = paginator or Paginator
try:
return paginator(
object_list,
per_page,
orphans=orphans,
allow_empty_first_page=allow_empty_first_page,
).page(page)
except (EmptyPage, InvalidPage):
raise Http404()
def pagination_dict(page):
pagination = {
"page": page.number,
"pages": page.paginator.num_pages,
"count": page.paginator.count,
"first": None,
"previous": None,
"next": None,
"last": None,
"before": 0,
"more": 0,
}
if page.has_previous():
pagination["first"] = 1
pagination["previous"] = page.previous_page_number()
if page.has_next():
pagination["last"] = page.paginator.num_pages
pagination["next"] = page.next_page_number()
if page.start_index():
pagination["before"] = page.start_index() - 1
pagination["more"] = page.paginator.count - page.end_index()
return pagination
def paginated_response(page, serializer=None, data=None, extra=None):
response_data = pagination_dict(page)
results = list(data or page.object_list)
if serializer:
results = serializer(results, many=True).data
response_data.update({"results": results})
if extra:
response_data.update(extra)
return Response(response_data)
def validate_slug(model, slug):
from .exceptions import OutdatedSlug
if model.slug != slug:
raise OutdatedSlug(model)
def get_int_or_404(value):
if str(value).isdigit():
return int(value)
raise Http404()
| 2,112
|
Python
|
.py
| 66
| 25.272727
| 71
| 0.647233
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,945
|
exceptions.py
|
rafalp_Misago/misago/core/exceptions.py
|
# pylint: disable=super-init-not-called
from django.core.exceptions import PermissionDenied
from django.db.models import Model
from social_core.exceptions import AuthException
class AjaxError(Exception):
"""You've tried to do something over AJAX but misago blurped"""
def __init__(self, message=None, code=406):
self.message = message
self.code = code
class Banned(PermissionDenied):
def __init__(self, ban=None):
if ban:
self.ban = ban
class SocialAuthFailed(AuthException):
"""Exception used to return error messages from Misago's social auth to user."""
def __init__(self, backend, message):
self.backend = backend
self.message = message
class SocialAuthBanned(AuthException):
"""Exception used to return ban message from Misago's social auth to user."""
def __init__(self, backend, ban):
self.backend = backend
self.ban = ban
class ExplicitFirstPage(Exception):
"""The url that was used to reach view contained explicit first page"""
class OutdatedSlug(Exception):
"""The url that was used to reach view contained outdated slug"""
| 1,154
|
Python
|
.py
| 27
| 37.333333
| 84
| 0.714928
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,946
|
errorpages.py
|
rafalp_Misago/misago/core/errorpages.py
|
from django.http import JsonResponse
from django.shortcuts import render
from django.utils.translation import pgettext
from social_core import exceptions as social_exceptions
from ..admin.views.errorpages import admin_csrf_failure, admin_error_page
from ..socialauth.providers import providers
from .exceptions import SocialAuthBanned, SocialAuthFailed
from .utils import get_exception_message, is_request_to_misago
def _is_ajax(request):
# Request is AJAX when done with XMLHttpRequest
if request.headers.get("x-requested-with") == "XMLHttpRequest":
return True
# Assume that request is AJAX when it has JSON payload
return "application/json" in request.headers.get("content-type", "")
def _ajax_error(code, exception=None, default_message=None):
return JsonResponse(
{"detail": get_exception_message(exception, default_message)},
status=code,
)
@admin_error_page
def _error_page(request, code, exception=None, default_message=None):
request.frontend_context.update({"CURRENT_LINK": "misago:error-%s" % code})
return render(
request,
"misago/errorpages/%s.html" % code,
{"message": get_exception_message(exception, default_message)},
status=code,
)
def banned(request, exception):
ban = exception.ban
request.frontend_context.update(
{"MESSAGE": ban.get_serialized_message(), "CURRENT_LINK": "misago:error-banned"}
)
return render(request, "misago/errorpages/banned.html", {"ban": ban}, status=403)
def permission_denied(request, exception):
if _is_ajax(request):
return _ajax_error(403, exception, pgettext("api", "Permission denied."))
return _error_page(request, 403, exception)
def page_not_found(request, exception):
if _is_ajax(request):
return _ajax_error(404, exception, "Not found.")
return _error_page(request, 404, exception)
def social_auth_failed(request, exception):
backend_name = None
ban = None
help_text = None
message = None
try:
backend_name = exception.backend_name
except AttributeError:
pass
try:
exception_backend = exception.backend
backend_name = providers.get_name(exception_backend.name)
except AttributeError:
pass
if isinstance(exception, social_exceptions.NotAllowedToDisconnect):
message = pgettext(
"social auth",
"A problem was encountered when disconnecting your account from the remote site.",
)
help_text = pgettext(
"social auth",
"You are not allowed to disconnect your account from the other site, because currently it's the only way to sign in to your account.",
)
elif backend_name:
message = pgettext(
"social auth",
"A problem was encountered when signing you in using %(backend)s.",
) % {"backend": backend_name}
if isinstance(exception, social_exceptions.AuthCanceled):
help_text = pgettext(
"social auth", "The sign in process has been canceled by user."
)
if isinstance(exception, social_exceptions.AuthUnreachableProvider):
help_text = pgettext(
"social auth", "The other service could not be reached."
)
if isinstance(exception, SocialAuthFailed):
help_text = exception.message
if isinstance(exception, SocialAuthBanned):
ban = exception.ban
else:
message = pgettext(
"social auth",
"Unexpected problem has been encountered during sign in process.",
)
return render(
request,
"misago/errorpages/social.html",
{
"backend_name": backend_name,
"ban": ban,
"message": message,
"help_text": help_text,
},
status=403,
)
@admin_csrf_failure
def csrf_failure(request, reason=""):
if _is_ajax(request):
return JsonResponse(
{
"detail": pgettext(
"api",
"Your request was rejected because your browser didn't send the CSRF cookie, or the cookie sent was invalid.",
)
},
status=403,
)
return render(request, "misago/errorpages/csrf_failure.html", status=403)
def not_allowed(request):
return _error_page(request, 405)
# Decorators for custom error page handlers
def shared_403_exception_handler(f):
def page_decorator(request, *args, **kwargs):
if is_request_to_misago(request):
return permission_denied(request, *args, **kwargs)
return f(request, *args, **kwargs)
return page_decorator
def shared_404_exception_handler(f):
def page_decorator(request, *args, **kwargs):
if is_request_to_misago(request):
return page_not_found(request, *args, **kwargs)
return f(request, *args, **kwargs)
return page_decorator
| 5,016
|
Python
|
.py
| 126
| 31.928571
| 146
| 0.655819
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,947
|
deprecations.py
|
rafalp_Misago/misago/core/deprecations.py
|
"""
Utility module useful for refactors,
Defines utility function for easy raising of warnings in deprecated functions.
This function is set to use stacklevel 3 as default making following code in test.py:
def depreacted_function():
warn("This function is deprecated")
def other_function():
deprecated_function()
Will raise warning about 1st line in other_function calling deprecated function.
"""
import warnings
class RemovedInMisagoWarning(Warning):
pass
def warn(message, category=RemovedInMisagoWarning, stacklevel=0):
warnings.warn(message, category, stacklevel + 3)
| 601
|
Python
|
.py
| 15
| 37.2
| 85
| 0.80662
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,948
|
decorators.py
|
rafalp_Misago/misago/core/decorators.py
|
from rest_framework import serializers
from .errorpages import not_allowed
def require_POST(f):
def decorator(request, *args, **kwargs):
if not request.method == "POST":
return not_allowed(request)
return f(request, *args, **kwargs)
return decorator
def require_dict_data(f):
def decorator(request, *args, **kwargs):
if request.method == "POST":
DummySerializer(data=request.data).is_valid(raise_exception=True)
return f(request, *args, **kwargs)
return decorator
class DummySerializer(serializers.Serializer):
pass
| 601
|
Python
|
.py
| 16
| 31.25
| 77
| 0.690972
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,949
|
views.py
|
rafalp_Misago/misago/core/views.py
|
from django.shortcuts import redirect
def forum_index(request):
return # blow up as this view is normally non-reachable!
def home_redirect(*args, **kwargs):
return redirect("misago:index")
| 202
|
Python
|
.py
| 5
| 37
| 61
| 0.761658
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,950
|
mail.py
|
rafalp_Misago/misago/core/mail.py
|
from django.core import mail as djmail
from django.template.loader import render_to_string
from django.utils.translation import get_language
from ..conf import settings
from .utils import get_host_from_address
def build_mail(recipient, subject, template, sender=None, context=None):
context = context.copy() if context else {}
if not context.get("settings"):
raise ValueError("settings key is missing from context")
forum_address = context["settings"].forum_address
context.update(
{
"LANGUAGE_CODE": get_language()[:2],
"LOGIN_URL": settings.LOGIN_URL,
"forum_host": get_host_from_address(forum_address),
"user": recipient,
"sender": sender,
"subject": subject,
}
)
message_plain = render_to_string("%s.txt" % template, context)
message_html = render_to_string("%s.html" % template, context)
message = djmail.EmailMultiAlternatives(
subject, message_plain, to=[recipient.email]
)
message.attach_alternative(message_html, "text/html")
return message
def mail_user(recipient, subject, template, sender=None, context=None):
message = build_mail(recipient, subject, template, sender, context)
message.send()
def mail_users(recipients, subject, template, sender=None, context=None):
messages = []
for recipient in recipients:
messages.append(build_mail(recipient, subject, template, sender, context))
if messages:
send_messages(messages)
def send_messages(messages):
connection = djmail.get_connection()
connection.send_messages(messages)
| 1,643
|
Python
|
.py
| 39
| 35.794872
| 82
| 0.697103
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,951
|
misago_json.py
|
rafalp_Misago/misago/core/templatetags/misago_json.py
|
import json
from django import template
from django.utils.safestring import mark_safe
from ..utils import encode_json_html
register = template.Library()
@register.filter
def as_json(value):
json_dump = json.dumps(value)
# fixes XSS as described in #651
return mark_safe(encode_json_html(json_dump))
| 316
|
Python
|
.py
| 10
| 28.9
| 49
| 0.780731
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,952
|
misago_absoluteurl.py
|
rafalp_Misago/misago/core/templatetags/misago_absoluteurl.py
|
from django import template
from django.urls import NoReverseMatch, reverse
register = template.Library()
@register.simple_tag(takes_context=True)
def absoluteurl(context, url_or_name, *args, **kwargs):
address = context["settings"].forum_address
if not address:
return None
absolute_url_prefix = address.rstrip("/")
try:
url_or_name = reverse(url_or_name, args=args, kwargs=kwargs)
except NoReverseMatch:
# don't use URLValidator because its too explicit
if not url_or_name.startswith("/"):
return url_or_name
return "%s%s" % (absolute_url_prefix, url_or_name)
| 636
|
Python
|
.py
| 16
| 34.125
| 68
| 0.697068
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,953
|
misago_batch.py
|
rafalp_Misago/misago/core/templatetags/misago_batch.py
|
from django import template
register = template.Library()
@register.filter
def batch(items, size):
batch_size = 0
batch_items = []
for item in items:
batch_size += 1
batch_items.append(item)
if batch_size == size:
yield batch_items
batch_size = 0
batch_items = []
if batch_items:
yield batch_items
@register.filter
def batchnonefilled(items, size):
batch_size = 0
batch_items = []
for item in items:
batch_size += 1
batch_items.append(item)
if batch_size == size:
yield batch_items
batch_size = 0
batch_items = []
if batch_size:
batch_items.extend([None] * (size - batch_size))
yield batch_items
| 783
|
Python
|
.py
| 29
| 19.551724
| 56
| 0.582773
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,954
|
misago_stringutils.py
|
rafalp_Misago/misago/core/templatetags/misago_stringutils.py
|
from django import template
register = template.Library()
@register.filter
def isdescriptionshort(string):
string_lowered = string.lower()
return string_lowered.count("<p") == 1 and not string_lowered.count("<br")
| 225
|
Python
|
.py
| 6
| 34.666667
| 78
| 0.759259
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,955
|
misago_capture.py
|
rafalp_Misago/misago/core/templatetags/misago_capture.py
|
"""
Capture tag: renders its contents as template, and stores them in value
Syntax:
{% capture trimmed as loremipsum %}
<a href="{% url 'misago:terms-of-service' %}">{% trans "guidelines" %}</a>
{% endcapture %} # renders block contents to context variable loremipsum
"""
from django import template
register = template.Library()
SYNTAX_ERROR = 'capture tag syntax is "capture [trimmed] as [value]"'
@register.tag()
def capture(parser, token):
split_contents = token.split_contents()
if len(split_contents) == 4:
if split_contents[1] != "trimmed" or split_contents[2].lower() != "as":
raise template.TemplateSyntaxError(SYNTAX_ERROR)
is_trimmed = True
variable = split_contents[3]
elif len(split_contents) == 3:
if split_contents[1].lower() != "as":
raise template.TemplateSyntaxError(SYNTAX_ERROR)
is_trimmed = False
variable = split_contents[2]
else:
raise template.TemplateSyntaxError(SYNTAX_ERROR)
nodelist = parser.parse(("endcapture",))
parser.delete_first_token()
return CaptureNode(variable, nodelist, trim=is_trimmed)
class CaptureNode(template.Node):
def __init__(self, variable, nodelist, trim=False):
self.variable = variable
self.nodelist = nodelist
self.is_trimmed = trim
def render(self, context):
captured_output = self.nodelist.render(context)
if self.is_trimmed:
captured_output = captured_output.strip()
context[self.variable] = captured_output
return ""
| 1,568
|
Python
|
.py
| 39
| 34.230769
| 79
| 0.676761
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,956
|
misago_pagetitle.py
|
rafalp_Misago/misago/core/templatetags/misago_pagetitle.py
|
from django import template
from django.utils.translation import pgettext
register = template.Library()
@register.simple_tag
def pagetitle(title, **kwargs):
if "page" in kwargs and kwargs["page"] > 1:
title += " (%s)" % (
pgettext("page title pagination", "page: %(page)s")
% {"page": kwargs["page"]}
)
if "parent" in kwargs:
title += " | %s" % kwargs["parent"]
return title
| 440
|
Python
|
.py
| 13
| 27.846154
| 63
| 0.606635
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,957
|
misago_shorthands.py
|
rafalp_Misago/misago/core/templatetags/misago_shorthands.py
|
from django import template
register = template.Library()
@register.filter
def iftrue(test, value):
return value if test else ""
@register.filter
def iffalse(test, value):
return "" if test else value
| 214
|
Python
|
.py
| 8
| 24.125
| 32
| 0.766169
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,958
|
0001_initial.py
|
rafalp_Misago/misago/core/migrations/0001_initial.py
|
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="CacheVersion",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("cache", models.CharField(max_length=128)),
("version", models.PositiveIntegerField(default=0)),
],
options={},
bases=(models.Model,),
)
]
| 743
|
Python
|
.py
| 24
| 16.791667
| 68
| 0.436364
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,959
|
0002_basic_settings.py
|
rafalp_Misago/misago/core/migrations/0002_basic_settings.py
|
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_core", "0001_initial"), ("misago_conf", "0001_initial")]
operations = []
| 181
|
Python
|
.py
| 4
| 41.5
| 85
| 0.718391
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,960
|
0003_delete_cacheversion.py
|
rafalp_Misago/misago/core/migrations/0003_delete_cacheversion.py
|
# Generated by Django 1.11.17 on 2019-01-08 19:49
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_core", "0002_basic_settings")]
operations = [migrations.DeleteModel(name="CacheVersion")]
| 248
|
Python
|
.py
| 5
| 46.4
| 62
| 0.7625
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,961
|
test_empty_file_can_be_hashed.py
|
rafalp_Misago/misago/core/tests/test_empty_file_can_be_hashed.py
|
from ..utils import HASH_LENGTH, get_file_hash
def test_empty_file_hash_is_zeroes(mocker):
empty_file = mocker.Mock(size=0)
assert get_file_hash(empty_file) == "0" * HASH_LENGTH
| 188
|
Python
|
.py
| 4
| 43.5
| 57
| 0.71978
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,962
|
test_exceptionhandlers.py
|
rafalp_Misago/misago/core/tests/test_exceptionhandlers.py
|
import json
from django.core import exceptions as django_exceptions
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.test import TestCase
from .. import exceptionhandler
from ...users.models import Ban
from ..exceptions import Banned
INVALID_EXCEPTIONS = [
django_exceptions.ObjectDoesNotExist,
django_exceptions.ViewDoesNotExist,
TypeError,
ValueError,
KeyError,
]
class IsMisagoExceptionTests(TestCase):
def test_is_misago_exception_true_for_handled_exceptions(self):
"""exceptionhandler.is_misago_exception recognizes handled exceptions"""
for exception in exceptionhandler.HANDLED_EXCEPTIONS:
self.assertTrue(exceptionhandler.is_misago_exception(exception()))
def test_is_misago_exception_false_for_not_handled_exceptions(self):
"""exceptionhandler.is_misago_exception fails to recognize other exceptions"""
for exception in INVALID_EXCEPTIONS:
self.assertFalse(exceptionhandler.is_misago_exception(exception()))
class GetExceptionHandlerTests(TestCase):
def test_exception_handlers_list(self):
"""HANDLED_EXCEPTIONS length matches that of EXCEPTION_HANDLERS"""
self.assertEqual(
len(exceptionhandler.HANDLED_EXCEPTIONS),
len(exceptionhandler.EXCEPTION_HANDLERS),
)
def test_get_exception_handler_for_handled_exceptions(self):
"""Exception handler has correct handler for every Misago exception"""
for exception in exceptionhandler.HANDLED_EXCEPTIONS:
exceptionhandler.get_exception_handler(exception())
def test_get_exception_handler_for_non_handled_exceptio(self):
"""Exception handler has no handler for non-supported exception"""
for exception in INVALID_EXCEPTIONS:
with self.assertRaises(ValueError):
exceptionhandler.get_exception_handler(exception())
class HandleAPIExceptionTests(TestCase):
def test_banned(self):
"""banned exception is correctly handled"""
ban = Ban(user_message="This is test ban!")
response = exceptionhandler.handle_api_exception(Banned(ban), None)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.data["ban"]["message"]["html"], "<p>This is test ban!</p>"
)
def test_permission_denied(self):
"""permission denied exception is correctly handled"""
response = exceptionhandler.handle_api_exception(PermissionDenied(), None)
self.assertEqual(response.status_code, 403)
self.assertEqual(
response.data["detail"],
"You do not have permission to perform this action.",
)
def test_permission_message_denied(self):
"""permission denied with message is correctly handled"""
exception = PermissionDenied("You shall not pass!")
response = exceptionhandler.handle_api_exception(exception, None)
self.assertEqual(response.status_code, 403)
self.assertEqual(response.data["detail"], "You shall not pass!")
def test_unhandled_exception(self):
"""our exception handler is not interrupting other exceptions"""
for exception in INVALID_EXCEPTIONS:
response = exceptionhandler.handle_api_exception(exception(), None)
self.assertIsNone(response)
response = exceptionhandler.handle_api_exception(Http404(), None)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.data["detail"], "Not found.")
def test_misago_handler_handles_htmx_404_exception_with_message(rf):
request = rf.get("/", headers={"hx-request": "true"})
request.is_htmx = True
response = exceptionhandler.handle_misago_exception(
request, Http404("Thread not found")
)
assert response.status_code == 404
assert response["content-type"] == "application/json"
assert json.loads(response.content) == {"error": "Thread not found"}
def test_misago_handler_handles_htmx_404_exception_without_message(rf):
request = rf.get("/", headers={"hx-request": "true"})
request.is_htmx = True
response = exceptionhandler.handle_misago_exception(request, Http404())
assert response.status_code == 404
assert response["content-type"] == "text/html; charset=utf-8"
assert not response.content
def test_misago_handler_handles_htmx_403_exception_with_message(rf):
request = rf.get("/", headers={"hx-request": "true"})
request.is_htmx = True
response = exceptionhandler.handle_misago_exception(
request, PermissionDenied("Thread is closed")
)
assert response.status_code == 403
assert response["content-type"] == "application/json"
assert json.loads(response.content) == {"error": "Thread is closed"}
def test_misago_handler_handles_htmx_403_exception_without_message(rf):
request = rf.get("/", headers={"hx-request": "true"})
request.is_htmx = True
response = exceptionhandler.handle_misago_exception(request, PermissionDenied())
assert response.status_code == 403
assert response["content-type"] == "text/html; charset=utf-8"
assert not response.content
| 5,208
|
Python
|
.py
| 103
| 43.640777
| 86
| 0.715271
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,963
|
test_templatetags.py
|
rafalp_Misago/misago/core/tests/test_templatetags.py
|
from django.template import Context, Template
from django.test import TestCase
from ..templatetags.misago_batch import batch, batchnonefilled
class CaptureTests(TestCase):
def setUp(self):
self.context = Context({"unsafe_name": "The<hr>Html"})
def test_capture(self):
"""capture content to variable"""
tpl_content = """
{% load misago_capture %}
{% capture as the_var %}
{{ unsafe_name }}
{% endcapture %}
Hello, <b>{{ the_var|safe }}</b>
"""
tpl = Template(tpl_content)
render = tpl.render(self.context).strip()
self.assertIn("The<hr>Html", render)
self.assertNotIn("<b>The<hr>Html</b>", render)
def test_capture_trimmed(self):
"""capture trimmed content to variable"""
tpl_content = """
{% load misago_capture %}
{% capture trimmed as the_var %}
{{ unsafe_name }}
{% endcapture %}
Hello, <b>{{ the_var|safe }}</b>
"""
tpl = Template(tpl_content)
render = tpl.render(self.context).strip()
self.assertIn("<b>The<hr>Html</b>", render)
class BatchTests(TestCase):
def test_batch(self):
"""standard batch yields valid results"""
value = "loremipsum"
result = [["l", "o", "r"], ["e", "m", "i"], ["p", "s", "u"], ["m"]]
for i, test_result in enumerate(batch(value, 3)):
self.assertEqual(test_result, result[i])
def test_batchnonefilled(self):
"""none-filled batch yields valid results"""
value = "loremipsum"
result = [["l", "o", "r"], ["e", "m", "i"], ["p", "s", "u"], ["m", None, None]]
for i, test_result in enumerate(batchnonefilled(value, 3)):
self.assertEqual(test_result, result[i])
class MockUser:
id = 12
pk = 12
username = "User"
slug = "user"
class ShorthandsTests(TestCase):
def test_iftrue_for_true(self):
"""iftrue renders value for true"""
tpl_content = """
{% load misago_shorthands %}
{{ value|iftrue:result }}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(Context({"result": "Ok!", "value": True})).strip(), "Ok!"
)
def test_iftrue_for_false(self):
"""iftrue isnt rendering value for false"""
tpl_content = """
{% load misago_shorthands %}
{{ value|iftrue:result }}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(Context({"result": "Ok!", "value": False})).strip(), ""
)
def test_iffalse_for_true(self):
"""iffalse isnt rendering value for true"""
tpl_content = """
{% load misago_shorthands %}
{{ value|iffalse:result }}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(Context({"result": "Ok!", "value": True})).strip(), ""
)
def test_iffalse_for_false(self):
"""iffalse renders value for false"""
tpl_content = """
{% load misago_shorthands %}
{{ value|iffalse:result }}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(Context({"result": "Ok!", "value": False})).strip(), "Ok!"
)
class JSONTests(TestCase):
def test_json_filter(self):
"""as_json filter renders dict as safe json"""
tpl_content = """
{% load misago_json %}
{{ value|as_json }}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(Context({"value": {"he</script>llo": 'bo"b!'}})).strip(),
r'{"he\u003C/script>llo": "bo\"b!"}',
)
class PageTitleTests(TestCase):
def test_single_title(self):
"""tag passes trough single title"""
tpl_content = """
{% load misago_pagetitle %}
{% pagetitle item %}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(Context({"item": "Lorem Ipsum"})).strip(), "Lorem Ipsum"
)
def test_parent_title(self):
"""tag builds full title from title and parent name"""
tpl_content = """
{% load misago_pagetitle %}
{% pagetitle item parent=parent %}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(
Context({"item": "Lorem Ipsum", "parent": "Some Thread"})
).strip(),
"Lorem Ipsum | Some Thread",
)
def test_paged_title(self):
"""tag builds full title from title and page number"""
tpl_content = """
{% load misago_pagetitle %}
{% pagetitle item page=3 %}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(Context({"item": "Lorem Ipsum"})).strip(),
"Lorem Ipsum (page: 3)",
)
def test_kitchensink_title(self):
"""tag builds full title from all options"""
tpl_content = """
{% load misago_pagetitle %}
{% pagetitle item page=3 parent=parent %}
"""
tpl = Template(tpl_content)
self.assertEqual(
tpl.render(
Context({"item": "Lorem Ipsum", "parent": "Some Thread"})
).strip(),
"Lorem Ipsum (page: 3) | Some Thread",
)
| 5,199
|
Python
|
.py
| 150
| 27.193333
| 87
| 0.56666
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,964
|
test_common_middleware_redirect.py
|
rafalp_Misago/misago/core/tests/test_common_middleware_redirect.py
|
from ...users.test import AuthenticatedUserTestCase
class CommonMiddlewareRedirectTests(AuthenticatedUserTestCase):
def test_slashless_redirect(self):
"""
Regression test for https://github.com/rafalp/Misago/issues/450
there shouldn't be crash when request path lacks trailing slash
"""
response = self.client.get(self.user.get_absolute_url()[:-1])
self.assertEqual(response.status_code, 301)
self.assertTrue(response["location"].endswith(self.user.get_absolute_url()))
| 533
|
Python
|
.py
| 10
| 46
| 84
| 0.723077
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,965
|
test_exceptionhandler_middleware.py
|
rafalp_Misago/misago/core/tests/test_exceptionhandler_middleware.py
|
from django.http import Http404
from django.test.client import RequestFactory
from django.urls import reverse
from ...acl.useracl import get_user_acl
from ...categories.proxy import CategoriesProxy
from ...conf.dynamicsettings import DynamicSettings
from ...conftest import get_cache_versions
from ...permissions.proxy import UserPermissionsProxy
from ...users.models import AnonymousUser
from ..middleware import ExceptionHandlerMiddleware
def create_request():
request = RequestFactory().get(reverse("misago:index"))
request.cache_versions = get_cache_versions()
request.settings = DynamicSettings(request.cache_versions)
request.user = AnonymousUser()
request.user_acl = get_user_acl(request.user, request.cache_versions)
request.user_permissions = UserPermissionsProxy(
request.user, request.cache_versions
)
request.categories = CategoriesProxy(
request.user_permissions, request.cache_versions
)
request.include_frontend_context = True
request.frontend_context = {}
request.socialauth = {}
request.is_htmx = False
return request
def get_response(*_args):
raise NotImplementedError()
def test_exception_handler_middleware_returns_response_for_supported_exception(db):
"""Middleware returns HttpResponse for supported exception"""
middleware = ExceptionHandlerMiddleware(get_response)
exception = Http404()
assert middleware.process_exception(create_request(), exception)
def test_exception_handler_middleware_returns_none_for_non_supported_exception(db):
"""Middleware returns None for non-supported exception"""
middleware = ExceptionHandlerMiddleware(get_response)
exception = TypeError()
assert middleware.process_exception(create_request(), exception) is None
| 1,786
|
Python
|
.py
| 39
| 41.794872
| 83
| 0.783084
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,966
|
test_serializers.py
|
rafalp_Misago/misago/core/tests/test_serializers.py
|
from django.test import TestCase
from rest_framework import serializers
from ...categories.models import Category
from ...threads import test
from ...threads.models import Thread
from ..serializers import MutableFields
class Serializer(serializers.ModelSerializer, MutableFields):
url = serializers.SerializerMethodField()
class Meta:
model = Thread
fields = [
"id",
"title",
"replies",
"has_unapproved_posts",
"started_on",
"last_post_on",
"last_post_is_event",
"last_post",
"last_poster_name",
"is_unapproved",
"is_hidden",
"is_closed",
"weight",
]
class MutableFieldsSerializerTests(TestCase):
def test_subset_fields(self):
"""classmethod subset_fields creates new serializer"""
category = Category.objects.get(slug="first-category")
thread = test.post_thread(category=category)
fields = ["id", "title", "replies", "last_poster_name"]
serializer = Serializer.subset_fields(*fields)
self.assertEqual(
serializer.__name__, "SerializerIdTitleRepliesLastPosterNameSubset"
)
self.assertEqual(serializer.Meta.fields, fields)
serialized_thread = serializer(thread).data
self.assertEqual(
serialized_thread,
{
"id": thread.id,
"title": thread.title,
"replies": thread.replies,
"last_poster_name": thread.last_poster_name,
},
)
self.assertFalse(Serializer.Meta.fields == serializer.Meta.fields)
def test_exclude_fields(self):
"""classmethod exclude_fields creates new serializer"""
category = Category.objects.get(slug="first-category")
thread = test.post_thread(category=category)
kept_fields = ["id", "title", "weight"]
removed_fields = list(set(Serializer.Meta.fields) - set(kept_fields))
serializer = Serializer.exclude_fields(*removed_fields)
self.assertEqual(serializer.__name__, "SerializerIdTitleWeightSubset")
self.assertEqual(serializer.Meta.fields, kept_fields)
serialized_thread = serializer(thread).data
self.assertEqual(
serialized_thread,
{"id": thread.id, "title": thread.title, "weight": thread.weight},
)
self.assertFalse(Serializer.Meta.fields == serializer.Meta.fields)
def test_extend_fields(self):
"""classmethod extend_fields creates new serializer"""
category = Category.objects.get(slug="first-category")
thread = test.post_thread(category=category)
serializer = Serializer.extend_fields("category")
serialized_thread = serializer(thread).data
self.assertEqual(serialized_thread["category"], category.pk)
| 2,918
|
Python
|
.py
| 69
| 32.681159
| 79
| 0.635465
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,967
|
test_page.py
|
rafalp_Misago/misago/core/tests/test_page.py
|
from django.test import TestCase
from ..page import Page
class SiteTests(TestCase):
def setUp(self):
self.page = Page("test")
def test_pages(self):
"""add_section adds section to page"""
self.page.add_section(
link="misago:user-posts", name="Posts", after="misago:user-threads"
)
self.page.add_section(link="misago:user-threads", name="Threads")
self.page.add_section(
link="misago:user-follows", name="Follows", before="misago:user-posts"
)
self.page.assert_is_finalized()
sorted_sections = self.page._sorted_list
self.assertEqual(sorted_sections[0]["name"], "Threads")
self.assertEqual(sorted_sections[1]["name"], "Follows")
self.assertEqual(sorted_sections[2]["name"], "Posts")
self.assertEqual(self.page.get_default_link(), "misago:user-threads")
| 896
|
Python
|
.py
| 20
| 36.55
| 82
| 0.645905
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,968
|
test_context_processors.py
|
rafalp_Misago/misago/core/tests/test_context_processors.py
|
from django.test import TestCase
from django.utils import translation
from .. import context_processors
class MockRequest:
path = "/"
def __init__(self, secure, host):
self.secure = secure
self.host = host
def is_secure(self):
return self.secure
def get_host(self):
return self.host
class MetaMockRequest:
def __init__(self, meta):
self.META = meta
class MomentjsLocaleTests(TestCase):
def test_momentjs_locale(self):
"""momentjs_locale adds MOMENTJS_LOCALE_URL to context"""
with translation.override("no-no"):
self.assertEqual(
context_processors.momentjs_locale(True), {"MOMENTJS_LOCALE_URL": None}
)
with translation.override("en-us"):
self.assertEqual(
context_processors.momentjs_locale(True), {"MOMENTJS_LOCALE_URL": None}
)
with translation.override("de"):
self.assertEqual(
context_processors.momentjs_locale(True),
{"MOMENTJS_LOCALE_URL": "misago/momentjs/de.js"},
)
with translation.override("pl-de"):
self.assertEqual(
context_processors.momentjs_locale(True),
{"MOMENTJS_LOCALE_URL": "misago/momentjs/pl.js"},
)
class FrontendContextTests(TestCase):
def test_frontend_context(self):
"""frontend_context is available in templates"""
mock_request = MockRequest(False, "somewhere.com")
mock_request.include_frontend_context = True
mock_request.frontend_context = {"someValue": "Something"}
self.assertEqual(
context_processors.frontend_context(mock_request),
{"frontend_context": {"someValue": "Something"}},
)
mock_request.include_frontend_context = False
self.assertEqual(context_processors.frontend_context(mock_request), {})
| 1,944
|
Python
|
.py
| 48
| 31.0625
| 87
| 0.630122
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,969
|
test_frontendcontext_middleware.py
|
rafalp_Misago/misago/core/tests/test_frontendcontext_middleware.py
|
from django.http import HttpResponse
from ..middleware import FrontendContextMiddleware
class MockRequest:
pass
def get_response(*_):
return HttpResponse("OK!")
def test_frontend_middleware_sets_frontend_context_dict_on_request():
request = MockRequest()
FrontendContextMiddleware(get_response)(request)
assert request.frontend_context == {}
| 369
|
Python
|
.py
| 10
| 33.2
| 69
| 0.786932
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,970
|
test_utils.py
|
rafalp_Misago/misago/core/tests/test_utils.py
|
from django.core.exceptions import PermissionDenied
from django.test import TestCase
from django.test.client import RequestFactory
from django.urls import Resolver404, reverse
from django.utils.functional import lazy, lazystr
from ..utils import (
clean_ids_list,
clean_return_path,
format_plaintext_for_html,
get_exception_message,
get_host_from_address,
is_referer_local,
is_request_to_misago,
parse_iso8601_string,
slugify,
)
class IsRequestToMisagoTests(TestCase):
def test_is_request_to_misago(self):
"""
is_request_to_misago correctly detects requests directed at Misago
"""
VALID_PATHS = ("/", "/threads/")
INVALID_PATHS = ("", "somewhere/")
misago_prefix = reverse("misago:index")
for path in VALID_PATHS:
request = RequestFactory().get("/")
request.path = path
self.assertTrue(
is_request_to_misago(request),
'"%s" is not overlapped by "%s"' % (path, misago_prefix),
)
for path in INVALID_PATHS:
request = RequestFactory().get("/")
request.path = path
self.assertFalse(
is_request_to_misago(request),
'"%s" is overlapped by "%s"' % (path, misago_prefix),
)
class SlugifyTests(TestCase):
def test_valid_slugify_output(self):
"""Misago's slugify correctly slugifies string"""
test_cases = [
("User", "user"),
("Eric The Fish", "eric-the-fish"),
("John Snow", "john-snow"),
("J0n", "j0n"),
("An###ne", "anne"),
("S**t", "st"),
("Łók", "lok"),
]
for original, slug in test_cases:
self.assertEqual(slugify(original), slug)
class ParseIso8601StringTests(TestCase):
def test_valid_input(self):
"""util parses iso 8601 strings"""
INPUTS = [
"2016-10-22T20:55:39.185085Z",
"2016-10-22T20:55:39.185085-01:00",
"2016-10-22T20:55:39-01:00",
"2016-10-22T20:55:39.185085+01:00",
]
for test_input in INPUTS:
self.assertTrue(parse_iso8601_string(test_input))
def test_invalid_input(self):
"""util throws ValueError on invalid input"""
INPUTS = [
"",
"2016-10-22",
"2016-10-22T30:55:39.185085+11:00",
"2016-10-22T20:55:39.18SSSSS5085Z",
]
for test_input in INPUTS:
with self.assertRaises(ValueError):
self.assertTrue(parse_iso8601_string(test_input))
PLAINTEXT_FORMAT_CASES = [
("Lorem ipsum.", "<p>Lorem ipsum.</p>"),
("Lorem <b>ipsum</b>.", "<p>Lorem <b>ipsum</b>.</p>"),
('Lorem "ipsum" dolor met.', "<p>Lorem "ipsum" dolor met.</p>"),
("Lorem ipsum.\nDolor met.", "<p>Lorem ipsum.<br>Dolor met.</p>"),
("Lorem ipsum.\n\nDolor met.", "<p>Lorem ipsum.</p>\n\n<p>Dolor met.</p>"),
(
"http://misago-project.org/login/",
(
"<p>"
'<a href="http://misago-project.org/login/">'
"http://misago-project.org/login/"
"</a>"
"</p>"
),
),
]
class FormatPlaintextForHtmlTests(TestCase):
def test_format_plaintext_for_html(self):
"""format_plaintext_for_html correctly formats plaintext for html"""
for plaintext, html in PLAINTEXT_FORMAT_CASES:
output = format_plaintext_for_html(plaintext)
assertion_message = """
format_plaintext_for_html failed to produce expected output:
expected: %s
return: %s
""" % (
html,
output,
)
self.assertEqual(output, html, assertion_message)
class MockRequest:
scheme = "http"
def __init__(self, method, meta=None, post=None):
self.method = method
self.META = meta or {}
self.POST = post or {}
class CleanReturnPathTests(TestCase):
def test_get_request(self):
"""clean_return_path works for GET requests"""
bad_request = MockRequest(
"GET",
{"HTTP_REFERER": "http://cookies.com", "HTTP_HOST": "misago-project.org"},
)
self.assertIsNone(clean_return_path(bad_request))
bad_request = MockRequest(
"GET",
{
"HTTP_REFERER": "https://misago-project.org/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertIsNone(clean_return_path(bad_request))
bad_request = MockRequest(
"GET",
{
"HTTP_REFERER": "https://misago-project.org/",
"HTTP_HOST": "misago-project.org/assadsa/",
},
)
self.assertIsNone(clean_return_path(bad_request))
ok_request = MockRequest(
"GET",
{
"HTTP_REFERER": "http://misago-project.org/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertEqual(clean_return_path(ok_request), "/")
ok_request = MockRequest(
"GET",
{
"HTTP_REFERER": "http://misago-project.org/login/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertEqual(clean_return_path(ok_request), "/login/")
def test_post_request(self):
"""clean_return_path works for POST requests"""
bad_request = MockRequest(
"POST",
{
"HTTP_REFERER": "http://misago-project.org/",
"HTTP_HOST": "misago-project.org/",
},
{"return_path": "/sdasdsa/"},
)
self.assertIsNone(clean_return_path(bad_request))
ok_request = MockRequest(
"POST",
{
"HTTP_REFERER": "http://misago-project.org/",
"HTTP_HOST": "misago-project.org/",
},
{"return_path": "/login/"},
)
self.assertEqual(clean_return_path(ok_request), "/login/")
class IsRefererLocalTests(TestCase):
def test_local_referers(self):
"""local referers return true"""
ok_request = MockRequest(
"GET",
{
"HTTP_REFERER": "http://misago-project.org/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertTrue(is_referer_local(ok_request))
ok_request = MockRequest(
"GET",
{
"HTTP_REFERER": "http://misago-project.org/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertTrue(is_referer_local(ok_request))
ok_request = MockRequest(
"GET",
{
"HTTP_REFERER": "http://misago-project.org/login/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertTrue(is_referer_local(ok_request))
def test_foreign_referers(self):
"""non-local referers return false"""
bad_request = MockRequest(
"GET",
{
"HTTP_REFERER": "http://else-project.org/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertFalse(is_referer_local(bad_request))
bad_request = MockRequest(
"GET",
{
"HTTP_REFERER": "https://misago-project.org/",
"HTTP_HOST": "misago-project.org/",
},
)
self.assertFalse(is_referer_local(bad_request))
bad_request = MockRequest(
"GET",
{
"HTTP_REFERER": "http://misago-project.org/",
"HTTP_HOST": "misago-project.org/assadsa/",
},
)
self.assertFalse(is_referer_local(bad_request))
class GetExceptionMessageTests(TestCase):
def test_no_args(self):
"""both of helper args are optional"""
message = get_exception_message()
self.assertIsNone(message)
def test_no_default_message(self):
"""helper's default message arg is optional"""
message = get_exception_message(PermissionDenied("Lorem Ipsum"))
self.assertEqual(message, "Lorem Ipsum")
message = get_exception_message(PermissionDenied(lazystr("Lazy Error")))
self.assertEqual(message, "Lazy Error")
message = get_exception_message(PermissionDenied())
self.assertIsNone(message)
def test_default_message(self):
"""helper's default message arg is used"""
message = get_exception_message(PermissionDenied("Lorem Ipsum"), "Default")
self.assertEqual(message, "Lorem Ipsum")
message = get_exception_message(PermissionDenied(), "Default")
self.assertEqual(message, "Default")
message = get_exception_message(Resolver404({"path": "/invalid/"}), "Default")
self.assertEqual(message, "Default")
message = get_exception_message(default_message="Lorem Ipsum")
self.assertEqual(message, "Lorem Ipsum")
class CleanIdsListTests(TestCase):
def test_valid_list(self):
"""list of valid ids is cleaned"""
self.assertEqual(clean_ids_list(["1", 3, "42"], None), [1, 3, 42])
def test_empty_list(self):
"""empty list passes validation"""
self.assertEqual(clean_ids_list([], None), [])
def test_string_list(self):
"""string list passes validation"""
self.assertEqual(clean_ids_list("1234", None), [1, 2, 3, 4])
def test_message(self):
"""utility uses passed message for exception"""
with self.assertRaisesMessage(PermissionDenied, "Test error message!"):
clean_ids_list(None, "Test error message!")
def test_invalid_inputs(self):
"""utility raises exception for invalid inputs"""
INVALID_INPUTS = (
None,
"abc",
[None],
[1, 2, "a", 4],
[1, None, 3],
{1: 2, "a": 4},
)
for invalid_input in INVALID_INPUTS:
with self.assertRaisesMessage(PermissionDenied, "Test error message!"):
clean_ids_list(invalid_input, "Test error message!")
class GetHostFromAddressTests(TestCase):
def test_none(self):
"""get_host_from_address returns None for None"""
result = get_host_from_address(None)
self.assertIsNone(result)
def test_empty_string(self):
"""get_host_from_address returns None for empty string"""
result = get_host_from_address("")
self.assertIsNone(result)
def test_hostname(self):
"""get_host_from_address returns hostname unchanged"""
result = get_host_from_address("hostname")
self.assertEqual(result, "hostname")
def test_hostname_with_trailing_slash(self):
"""get_host_from_address returns hostname for hostname with trailing slash"""
result = get_host_from_address("//hostname")
self.assertEqual(result, "hostname")
def test_hostname_with_port(self):
"""get_host_from_address returns hostname for hostname with port"""
result = get_host_from_address("hostname:8888")
self.assertEqual(result, "hostname")
def test_hostname_with_port_path_and_protocol(self):
"""get_host_from_address returns hostname for hostname with port and path"""
result = get_host_from_address("https://hostname:8888/somewhere/else/")
self.assertEqual(result, "hostname")
| 11,607
|
Python
|
.py
| 299
| 28.80602
| 86
| 0.569764
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,971
|
test_body_css_class.py
|
rafalp_Misago/misago/core/tests/test_body_css_class.py
|
from django.urls import reverse
from ...test import assert_contains, assert_not_contains
def test_body_has_misago_anonymous_css_class_if_user_is_anonymous(db, client):
response = client.get(reverse("misago:index"))
assert_contains(response, 'class="misago-anonymous')
assert_not_contains(response, 'class="misago-authenticated')
def test_body_has_misago_authenticated_css_class_if_user_is_authenticated(user_client):
response = user_client.get(reverse("misago:index"))
assert_contains(response, 'class="misago-authenticated')
assert_not_contains(response, 'class="misago-anonymous')
| 612
|
Python
|
.py
| 10
| 57.3
| 87
| 0.773869
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,972
|
test_errorpages.py
|
rafalp_Misago/misago/core/tests/test_errorpages.py
|
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.test import Client, TestCase, override_settings
from django.test.client import RequestFactory
from django.urls import reverse
from ...acl.useracl import get_user_acl
from ...categories.proxy import CategoriesProxy
from ...conf.dynamicsettings import DynamicSettings
from ...conftest import get_cache_versions
from ...permissions.proxy import UserPermissionsProxy
from ...users.models import AnonymousUser
from ..testproject.views import mock_custom_403_error_page, mock_custom_404_error_page
from ..utils import encode_json_html
class CSRFErrorViewTests(TestCase):
def test_csrf_failure_is_handled(self):
"""csrf_failure error page has no show-stoppers"""
csrf_client = Client(enforce_csrf_checks=True)
response = csrf_client.post(reverse("misago:index"), data={"eric": "fish"})
self.assertContains(response, "Request blocked", status_code=403)
def test_ajax_csrf_failure_is_handled(self):
"""csrf_failure error ajax response has no show-stoppers"""
csrf_client = Client(enforce_csrf_checks=True)
response = csrf_client.post(
reverse("misago:api:auth"),
data={"eric": "fish"},
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertContains(response, "CSRF cookie", status_code=403)
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class ErrorPageViewsTests(TestCase):
def test_banned_returns_403(self):
"""banned error page has no show-stoppers"""
response = self.client.get(reverse("raise-misago-banned"))
self.assertContains(response, "misago:error-banned", status_code=403)
self.assertContains(response, "<p>Banned for test!</p>", status_code=403)
self.assertContains(
response, encode_json_html("<p>Banned for test!</p>"), status_code=403
)
def test_permission_denied_returns_403(self):
"""permission_denied error page has no show-stoppers"""
response = self.client.get(reverse("raise-misago-403"))
self.assertContains(response, "misago:error-403", status_code=403)
self.assertContains(response, "Page not available", status_code=403)
def test_page_not_found_returns_404(self):
"""page_not_found error page has no show-stoppers"""
response = self.client.get(reverse("raise-misago-404"))
self.assertContains(response, "misago:error-404", status_code=404)
self.assertContains(response, "Page not found", status_code=404)
def test_not_allowed_returns_405(self):
"""not allowed error page has no showstoppers"""
response = self.client.get(reverse("raise-misago-405"))
self.assertContains(response, "misago:error-405", status_code=405)
self.assertContains(response, "Wrong way", status_code=405)
def test_social_auth_failed_returns_403(self):
"""social auth's failed error returns 403"""
response = self.client.get(reverse("raise-social-auth-failed"))
self.assertContains(response, "page-error-social", status_code=403)
self.assertContains(response, "GitHub", status_code=403)
def test_social_wrong_backend_returns_403(self):
"""social auth's wrong backend error returns 403"""
response = self.client.get(reverse("raise-social-wrong-backend"))
self.assertContains(response, "page-error-social", status_code=403)
def test_social_not_allowed_to_disconnect_returns_403(self):
"""social auth's not allowed to disconnect error returns 403"""
response = self.client.get(reverse("raise-social-not-allowed-to-disconnect"))
self.assertContains(response, "page-error-social", status_code=403)
def test_social_failed_message(self):
"""misago-specific social auth failed error page returns 403 with message"""
response = self.client.get(reverse("raise-social-auth-failed-message"))
self.assertContains(response, "page-error-social", status_code=403)
self.assertContains(
response, "This message will be shown to user!", status_code=403
)
def test_social_auth_banned(self):
"""misago-specific social auth banned error page returns 403 with ban message"""
response = self.client.get(reverse("raise-social-auth-banned"))
self.assertContains(response, "page-error-social", status_code=403)
self.assertContains(response, "Banned in auth!", status_code=403)
def create_request(url):
request = RequestFactory().get(url)
request.cache_versions = get_cache_versions()
request.settings = DynamicSettings(request.cache_versions)
request.user = AnonymousUser()
request.user_acl = get_user_acl(request.user, request.cache_versions)
request.user_permissions = UserPermissionsProxy(
request.user, request.cache_versions
)
request.categories = CategoriesProxy(
request.user_permissions, request.cache_versions
)
request.include_frontend_context = True
request.frontend_context = {}
request.socialauth = {}
request.is_htmx = False
return request
@override_settings(ROOT_URLCONF="misago.core.testproject.urlswitherrorhandlers")
class CustomErrorPagesTests(TestCase):
def setUp(self):
self.misago_request = create_request(reverse("misago:index"))
self.site_request = create_request(reverse("raise-403"))
def test_shared_403_decorator(self):
"""shared_403_decorator calls correct error handler"""
response = self.client.get(reverse("raise-misago-403"))
self.assertEqual(response.status_code, 403)
response = self.client.get(reverse("raise-403"))
self.assertContains(response, "Custom 403", status_code=403)
response = mock_custom_403_error_page(self.misago_request, PermissionDenied())
self.assertNotContains(response, "Custom 403", status_code=403)
response = mock_custom_403_error_page(self.site_request, PermissionDenied())
self.assertContains(response, "Custom 403", status_code=403)
def test_shared_404_decorator(self):
"""shared_404_decorator calls correct error handler"""
response = self.client.get(reverse("raise-misago-404"))
self.assertEqual(response.status_code, 404)
response = self.client.get(reverse("raise-404"))
self.assertContains(response, "Custom 404", status_code=404)
response = mock_custom_404_error_page(self.misago_request, Http404())
self.assertNotContains(response, "Custom 404", status_code=404)
response = mock_custom_404_error_page(self.site_request, Http404())
self.assertContains(response, "Custom 404", status_code=404)
| 6,768
|
Python
|
.py
| 120
| 49.25
| 88
| 0.71144
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,973
|
test_apipatch.py
|
rafalp_Misago/misago/core/tests/test_apipatch.py
|
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.test import TestCase
from ..apipatch import ApiPatch, InvalidAction
class MockRequest:
def __init__(self, data=None):
self.data = data
class MockObject:
def __init__(self, pk):
self.id = pk
self.pk = pk
class ApiPatchTests(TestCase):
def test_add(self):
"""add method adds function to patch object"""
patch = ApiPatch()
def mock_function():
pass
patch.add("test-add", mock_function)
self.assertEqual(len(patch._actions), 1)
self.assertEqual(patch._actions[0]["op"], "add")
self.assertEqual(patch._actions[0]["path"], "test-add")
self.assertEqual(patch._actions[0]["handler"], mock_function)
def test_remove(self):
"""remove method adds function to patch object"""
patch = ApiPatch()
def mock_function():
pass
patch.remove("test-remove", mock_function)
self.assertEqual(len(patch._actions), 1)
self.assertEqual(patch._actions[0]["op"], "remove")
self.assertEqual(patch._actions[0]["path"], "test-remove")
self.assertEqual(patch._actions[0]["handler"], mock_function)
def test_replace(self):
"""replace method adds function to patch object"""
patch = ApiPatch()
def mock_function():
pass
patch.replace("test-replace", mock_function)
self.assertEqual(len(patch._actions), 1)
self.assertEqual(patch._actions[0]["op"], "replace")
self.assertEqual(patch._actions[0]["path"], "test-replace")
self.assertEqual(patch._actions[0]["handler"], mock_function)
def test_validate_action(self):
"""validate_action method validates action dict"""
patch = ApiPatch()
VALID_ACTIONS = [
{"op": "add", "path": "test", "value": 42},
{"op": "remove", "path": "other-test", "value": "Lorem"},
{"op": "replace", "path": "false-test", "value": None},
]
for action in VALID_ACTIONS:
patch.validate_action(action)
# undefined op
UNSUPPORTED_ACTIONS = ({}, {"op": ""}, {"no": "op"})
for action in UNSUPPORTED_ACTIONS:
try:
patch.validate_action(action)
except InvalidAction as e:
self.assertEqual(e.args[0], "undefined op")
# unsupported op
try:
patch.validate_action({"op": "nope"})
except InvalidAction as e:
self.assertEqual(e.args[0], '"nope" op is unsupported')
# op lacking patch
try:
patch.validate_action({"op": "add"})
except InvalidAction as e:
self.assertEqual(e.args[0], '"add" op has to specify path')
# op lacking value
try:
patch.validate_action({"op": "add", "path": "yolo"})
except InvalidAction as e:
self.assertEqual(e.args[0], '"add" op has to specify value')
# empty value is allowed
try:
patch.validate_action({"op": "add", "path": "yolo", "value": ""})
except InvalidAction as e:
self.assertEqual(e.args[0], '"add" op has to specify value')
def test_dispatch_action(self):
"""dispatch_action calls specified actions"""
patch = ApiPatch()
mock_target = MockObject(13)
def action_a(request, target, value):
self.assertEqual(request, "request")
self.assertEqual(target, mock_target)
return {"a": value * 2, "b": 111}
patch.replace("abc", action_a)
def action_b(request, target, value):
self.assertEqual(request, "request")
self.assertEqual(target, mock_target)
return {"b": value * 10}
patch.replace("abc", action_b)
def action_fail(request, target, value):
self.fail("unrequired action was called")
patch.add("c", action_fail)
patch.remove("c", action_fail)
patch.replace("c", action_fail)
patch_dict = {"id": 123}
patch.dispatch_action(
patch_dict,
"request",
mock_target,
{"op": "replace", "path": "abc", "value": 5},
)
self.assertEqual(len(patch_dict), 3)
self.assertEqual(patch_dict["id"], 123)
self.assertEqual(patch_dict["a"], 10)
self.assertEqual(patch_dict["b"], 50)
def test_dispatch(self):
"""dispatch calls actions and returns response"""
patch = ApiPatch()
def action_error(request, target, value):
if value == "404":
raise Http404()
if value == "perm":
raise PermissionDenied("yo ain't doing that!")
patch.replace("error", action_error)
def action_mutate(request, target, value):
return {"value": value * 2}
patch.replace("mutate", action_mutate)
# dispatch requires list as an argument
response = patch.dispatch(MockRequest({}), {})
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.data["detail"], "PATCH request should be list of operations"
)
# valid dispatch
response = patch.dispatch(
MockRequest(
[
{"op": "replace", "path": "mutate", "value": 2},
{"op": "replace", "path": "mutate", "value": 6},
{"op": "replace", "path": "mutate", "value": 7},
]
),
MockObject(13),
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data["detail"]), 3)
self.assertEqual(response.data["detail"][0], "ok")
self.assertEqual(response.data["detail"][1], "ok")
self.assertEqual(response.data["detail"][2], "ok")
self.assertEqual(response.data["id"], 13)
self.assertEqual(response.data["value"], 14)
# invalid action in dispatch
response = patch.dispatch(
MockRequest(
[
{"op": "replace", "path": "mutate", "value": 2},
{"op": "replace", "path": "mutate", "value": 6},
{"op": "replace"},
{"op": "replace", "path": "mutate", "value": 7},
]
),
MockObject(13),
)
self.assertEqual(response.status_code, 400)
self.assertEqual(len(response.data["detail"]), 3)
self.assertEqual(response.data["detail"][0], "ok")
self.assertEqual(response.data["detail"][1], "ok")
self.assertEqual(response.data["detail"][2], '"replace" op has to specify path')
self.assertEqual(response.data["id"], 13)
self.assertEqual(response.data["value"], 12)
# action in dispatch raised 404
response = patch.dispatch(
MockRequest(
[
{"op": "replace", "path": "mutate", "value": 2},
{"op": "replace", "path": "error", "value": "404"},
{"op": "replace", "path": "mutate", "value": 6},
{"op": "replace", "path": "mutate", "value": 7},
]
),
MockObject(13),
)
self.assertEqual(response.status_code, 400)
self.assertEqual(len(response.data["detail"]), 2)
self.assertEqual(response.data["detail"][0], "ok")
self.assertEqual(response.data["detail"][1], "NOT FOUND")
self.assertEqual(response.data["id"], 13)
self.assertEqual(response.data["value"], 4)
# action in dispatch raised perm denied
response = patch.dispatch(
MockRequest(
[
{"op": "replace", "path": "mutate", "value": 2},
{"op": "replace", "path": "mutate", "value": 6},
{"op": "replace", "path": "mutate", "value": 9},
{"op": "replace", "path": "error", "value": "perm"},
]
),
MockObject(13),
)
self.assertEqual(response.status_code, 400)
self.assertEqual(len(response.data["detail"]), 4)
self.assertEqual(response.data["detail"][0], "ok")
self.assertEqual(response.data["detail"][1], "ok")
self.assertEqual(response.data["detail"][2], "ok")
self.assertEqual(response.data["detail"][3], "yo ain't doing that!")
self.assertEqual(response.data["id"], 13)
self.assertEqual(response.data["value"], 18)
| 8,686
|
Python
|
.py
| 202
| 31.915842
| 88
| 0.551916
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,974
|
test_deprecations.py
|
rafalp_Misago/misago/core/tests/test_deprecations.py
|
import warnings
from django.test import TestCase
from ..deprecations import RemovedInMisagoWarning, warn
class DeprecationsTests(TestCase):
def test_deprecations_warn(self):
"""deprecation utility raises warning"""
with warnings.catch_warnings(record=True) as warning:
warn("test warning")
self.assertEqual(len(warning), 1)
self.assertEqual(str(warning[0].message), "test warning")
self.assertTrue(issubclass(warning[0].category, RemovedInMisagoWarning))
| 528
|
Python
|
.py
| 11
| 40.363636
| 84
| 0.720703
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,975
|
test_context_processors_hook.py
|
rafalp_Misago/misago/core/tests/test_context_processors_hook.py
|
from ..context_processors import hooks
def test_context_processors_hook_can_inject_context(mocker):
plugin = mocker.Mock(return_value={"plugin": True})
mocker.patch("misago.core.context_processors.context_processors_hooks", [plugin])
context = hooks(None)
assert context == {"plugin": True}
| 309
|
Python
|
.py
| 6
| 47.5
| 85
| 0.744186
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,976
|
test_validators.py
|
rafalp_Misago/misago/core/tests/test_validators.py
|
import pytest
from django.core.exceptions import ValidationError
from ..validators import validate_image_square, validate_sluggable
def test_sluggable_validator_raises_error_if_result_slug_will_be_empty():
validator = validate_sluggable()
with pytest.raises(ValidationError):
validator("!#@! !@#@")
def test_sluggable_validator_raises_custom_error_if_result_slug_will_be_empty():
error_message = "I'm short custom error!"
validator = validate_sluggable(error_short=error_message)
with pytest.raises(ValidationError) as e:
validator("!#@! !@#@")
assert error_message in str(e.value)
def test_sluggable_validator_raises_error_if_result_slug_will_be_too_long():
validator = validate_sluggable()
with pytest.raises(ValidationError):
validator("a" * 256)
def test_sluggable_validator_raises_custom_error_if_result_slug_will_be_too_long():
error_message = "I'm long custom error!"
validator = validate_sluggable(error_long=error_message)
with pytest.raises(ValidationError) as e:
validator("a" * 256)
assert error_message in str(e.value)
def test_square_square_validator_validates_square_image(mocker):
image = mocker.Mock(width=100, height=100)
validate_image_square(image)
def test_square_square_validator_raises_error_if_image_is_not_square(mocker):
image = mocker.Mock(width=100, height=200)
with pytest.raises(ValidationError):
validate_image_square(image)
| 1,473
|
Python
|
.py
| 30
| 44.2
| 83
| 0.743357
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,977
|
test_mail.py
|
rafalp_Misago/misago/core/tests/test_mail.py
|
from django.core import mail
from django.test import TestCase
from django.urls import reverse
from ...cache.versions import get_cache_versions
from ...conf.dynamicsettings import DynamicSettings
from ...conf.test import override_dynamic_settings
from ...users.test import create_test_user
from ..mail import build_mail, mail_user, mail_users
class MailTests(TestCase):
def test_building_mail_without_context_raises_value_error(self):
user = create_test_user("User", "user@example.com")
with self.assertRaises(ValueError):
build_mail(user, "Misago Test Mail", "misago/emails/base")
def test_building_mail_without_settings_in_context_raises_value_error(self):
user = create_test_user("User", "user@example.com")
with self.assertRaises(ValueError):
build_mail(
user, "Misago Test Mail", "misago/emails/base", context={"settings": {}}
)
@override_dynamic_settings(forum_address="http://test.com/")
def test_mail_user(self):
"""mail_user sets message in backend"""
user = create_test_user("User", "user@example.com")
cache_versions = get_cache_versions()
settings = DynamicSettings(cache_versions)
mail_user(
user,
"Misago Test Mail",
"misago/emails/base",
context={"settings": settings},
)
self.assertEqual(mail.outbox[0].subject, "Misago Test Mail")
# assert that url to user's avatar is valid
html_body = mail.outbox[0].alternatives[0][0]
user_avatar_url = reverse(
"misago:user-avatar", kwargs={"pk": user.pk, "size": 32}
)
self.assertIn(user_avatar_url, html_body)
def test_mail_users(self):
"""mail_users sets messages in backend"""
cache_versions = get_cache_versions()
settings = DynamicSettings(cache_versions)
test_users = [
create_test_user("User1", "User1@example.com"),
create_test_user("Use2r", "User2@example.com"),
create_test_user("Us3er", "User3@example.com"),
create_test_user("U4ser", "User4@example.com"),
create_test_user("5User", "User5@example.com"),
]
mail_users(
test_users,
"Misago Test Spam",
"misago/emails/base",
context={"settings": settings},
)
spams_sent = 0
for message in mail.outbox:
if message.subject == "Misago Test Spam":
spams_sent += 1
self.assertEqual(spams_sent, len(test_users))
| 2,610
|
Python
|
.py
| 60
| 34.316667
| 88
| 0.623669
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,978
|
test_cursor_pagination.py
|
rafalp_Misago/misago/core/tests/test_cursor_pagination.py
|
import pytest
from ..cursorpagination import CursorPage, EmptyPage, InvalidPage, get_page
@pytest.fixture
def mock_objects(mocker):
return [mocker.Mock(post=i) for i in range(1, 12)]
@pytest.fixture
def mock_queryset(mocker, mock_objects):
return mocker.Mock(filter=mocker.Mock(return_value=mock_objects))
def test_paginator_returns_first_page(mock_objects):
assert get_page(mock_objects, "post", 6)
def test_first_page_has_first_flag(mock_objects):
page = get_page(mock_objects, "post", 6)
assert page.first
def test_first_page_start_is_zero(mock_objects):
page = get_page(mock_objects, "post", 6)
assert page.start == 0
def test_first_page_has_correct_length(mock_objects):
page = get_page(mock_objects, "post", 6)
assert len(page.object_list) == 6
def test_first_page_has_correct_items(mock_objects):
page = get_page(mock_objects, "post", 6)
assert page.object_list == mock_objects[:6]
def test_page_has_next_attr_pointing_to_first_item_of_next_page(mock_objects):
page = get_page(mock_objects, "post", 6)
assert page.next == 7
def test_requesting_next_page_filters_queryset_using_filter_name(mock_queryset):
page = get_page(mock_queryset, "post", 6, 7)
mock_queryset.filter.assert_called_once_with(post__gte=7)
def test_requesting_next_page_for_reversed_order_filters_queryset_with_descending(
mock_queryset,
):
page = get_page(mock_queryset, "-post", 6, 7)
mock_queryset.filter.assert_called_once_with(post__lte=7)
def test_requesting_next_page_limits_queryset_to_specified_length(mock_queryset):
page = get_page(mock_queryset, "post", 6, 7)
assert len(page.object_list) == 6
def test_paginator_returns_empty_first_page_without_errors():
get_page([], "post", 6)
def test_paginator_raises_empty_page_error_if_nth_page_is_empty(mocker):
queryset = mocker.Mock(filter=lambda **_: [])
with pytest.raises(EmptyPage):
get_page(queryset, "post", 6, 20)
def test_paginator_raises_invalid_page_error_if_starting_position_is_negative():
with pytest.raises(InvalidPage):
get_page(None, None, 0, -1)
def test_page_can_be_tested_to_see_if_next_page_exists(mock_objects):
page = get_page(mock_objects, "post", 6)
assert page.has_next()
def test_last_page_has_no_next(mock_objects):
page = get_page([], "post", 6)
assert not page.next
assert not page.has_next()
def test_cursor_page_is_first_if_start_is_zero():
page = CursorPage(0, [])
assert page.first
def test_cursor_page_is_not_first_if_start_is_not_zero():
page = CursorPage(1, [])
assert not page.first
| 2,635
|
Python
|
.py
| 58
| 41.241379
| 82
| 0.720866
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,979
|
test_absoluteurl_templatetag.py
|
rafalp_Misago/misago/core/tests/test_absoluteurl_templatetag.py
|
from unittest.mock import Mock
import pytest
from ..templatetags.misago_absoluteurl import absoluteurl
@pytest.fixture
def context():
return {"settings": Mock(forum_address="http://test.com/")}
def test_path_is_prefixed_with_forum_address(context):
assert absoluteurl(context, "/path/") == "http://test.com/path/"
def test_link_is_reversed_and_prefixed_with_forum_address(context):
assert absoluteurl(context, "misago:index") == "http://test.com/"
def test_absolute_url_is_not_changed(context):
url = "https://github.com/rafalp/Misago/issues/1067"
assert absoluteurl(context, url) == url
| 618
|
Python
|
.py
| 13
| 44.230769
| 69
| 0.74958
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,980
|
test_jsi18n.py
|
rafalp_Misago/misago/core/tests/test_jsi18n.py
|
import os
from django.conf import settings
from django.test import TestCase
from django.urls import reverse
from django.utils import translation
MISAGO_DIR = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
)
LOCALES_DIR = os.path.join(MISAGO_DIR, "locale")
class JsI18nUrlTests(TestCase):
def test_url_cache_buster(self):
"""js i18n catalog link has cachebuster with lang code"""
url = "%s?l=%s" % (reverse("django-i18n"), settings.LANGUAGE_CODE)
response = self.client.get(reverse("misago:index"))
self.assertContains(response, url)
def test_js_catalogs_are_correct(self):
"""no JS catalogs have showstoppers"""
failed_languages = []
for language in os.listdir(LOCALES_DIR):
if "." in language:
continue
try:
with translation.override(language):
response = self.client.get(reverse("django-i18n"))
if response.status_code != 200:
failed_languages.append(language)
except Exception: # pylint: disable=broad-except
failed_languages.append(language)
if failed_languages:
self.fail(
"JS catalog failed for languages: %s" % (", ".join(failed_languages))
)
| 1,352
|
Python
|
.py
| 32
| 32.78125
| 85
| 0.623762
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,981
|
test_views.py
|
rafalp_Misago/misago/core/tests/test_views.py
|
from django.test import TestCase, override_settings
from django.urls import reverse
class CoreViewsTests(TestCase):
def test_js_catalog_view_returns_200(self):
"""js catalog view has no show-stoppers"""
response = self.client.get("/django-i18n.js")
self.assertEqual(response.status_code, 200)
def test_robots_txt_returns_200(self):
"""robots.txt has no showstoppers"""
response = self.client.get("/robots.txt")
self.assertEqual(response["Content-type"], "text/plain")
self.assertContains(response, "/api/")
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class RedirectViewTests(TestCase):
def test_redirect_view(self):
"""redirect view always redirects to home page"""
response = self.client.get(reverse("test-redirect"))
self.assertEqual(response.status_code, 302)
self.assertTrue(response["location"].endswith(reverse("misago:index")))
| 961
|
Python
|
.py
| 19
| 44
| 79
| 0.708333
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,982
|
test_shortcuts.py
|
rafalp_Misago/misago/core/tests/test_shortcuts.py
|
from django.http import Http404
from django.test import TestCase, override_settings
from django.urls import reverse
from ..shortcuts import get_int_or_404
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class PaginateTests(TestCase):
def test_valid_page_handling(self):
"""Valid page number causes no errors"""
response = self.client.get(reverse("test-pagination", kwargs={"page": 2}))
self.assertEqual("5,6,7,8,9", response.content.decode())
def test_invalid_page_handling(self):
"""Invalid page number results in 404 error"""
response = self.client.get(reverse("test-pagination", kwargs={"page": 42}))
self.assertEqual(response.status_code, 404)
def test_implicit_page_handling(self):
"""Implicit page number causes no errors"""
response = self.client.get(reverse("test-pagination"))
self.assertEqual("0,1,2,3,4", response.content.decode())
def test_explicit_page_handling(self):
"""Explicit page number results in redirect"""
response = self.client.get(reverse("test-pagination", kwargs={"page": 1}))
valid_url = "/forum/test-pagination/"
self.assertEqual(response["Location"], valid_url)
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class ValidateSlugTests(TestCase):
def test_valid_slug_handling(self):
"""Valid slug causes no interruption in view processing"""
response = self.client.get(
reverse("validate-slug-view", kwargs={"slug": "eric-the-fish", "pk": 1})
)
self.assertContains(response, "Allright")
def test_invalid_slug_handling(self):
"""Invalid slug returns in redirect to valid page"""
response = self.client.get(
reverse("validate-slug-view", kwargs={"slug": "lion-the-eric", "pk": 1})
)
valid_url = "/forum/test-valid-slug/eric-the-fish-1/"
self.assertEqual(response["Location"], valid_url)
class GetIntOr404Tests(TestCase):
def test_valid_inputs(self):
"""get_int_or_404 returns int for valid values"""
VALID_VALUES = [("0", 0), ("123", 123), ("000123", 123), ("1", 1)]
for value, result in VALID_VALUES:
self.assertEqual(get_int_or_404(value), result)
def test_invalid_inputs(self):
"""get_int_or_404 raises Http404 for invalid values"""
INVALID_VALUES = [
None,
"",
"str",
"5tr",
"s0tr",
"str123",
"12.321",
".4",
"5.",
]
for value in INVALID_VALUES:
with self.assertRaises(Http404):
get_int_or_404(value)
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class PaginatedResponseTests(TestCase):
def test_page_response(self):
"""utility returns response for only page arg"""
response = self.client.get(reverse("test-paginated-response"))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"results": [i + 10 for i in range(10)],
"page": 2,
"pages": 10,
"count": 100,
"first": 1,
"previous": 1,
"next": 3,
"last": 10,
"before": 10,
"more": 80,
},
)
def test_explicit_data_response(self):
"""utility returns response with explicit data"""
response = self.client.get(reverse("test-paginated-response-data"))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"results": ["a", "b", "c", "d", "e"],
"page": 2,
"pages": 10,
"count": 100,
"first": 1,
"previous": 1,
"next": 3,
"last": 10,
"before": 10,
"more": 80,
},
)
def test_explicit_serializer_response(self):
"""utility returns response with data serialized via serializer"""
response = self.client.get(reverse("test-paginated-response-serializer"))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"results": [{"id": 0}, {"id": 2}, {"id": 4}, {"id": 6}],
"page": 1,
"pages": 1,
"count": 4,
"first": None,
"previous": None,
"next": None,
"last": None,
"before": 0,
"more": 0,
},
)
def test_explicit_data_serializer_response(self):
"""utility returns response with explicit data serialized via serializer"""
response = self.client.get(reverse("test-paginated-response-data-serializer"))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"results": [{"id": "aa"}, {"id": "bb"}, {"id": "cc"}, {"id": "dd"}],
"page": 1,
"pages": 1,
"count": 4,
"first": None,
"previous": None,
"next": None,
"last": None,
"before": 0,
"more": 0,
},
)
def test_explicit_data_extra_response(self):
"""utility returns response with explicit data and extra"""
response = self.client.get(reverse("test-paginated-response-data-extra"))
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.json(),
{
"results": ["a", "b", "c", "d"],
"page": 1,
"pages": 1,
"count": 4,
"first": None,
"previous": None,
"next": "EXTRA",
"last": None,
"before": 0,
"more": 0,
"lorem": "ipsum",
},
)
| 6,185
|
Python
|
.py
| 158
| 27.556962
| 86
| 0.52714
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,983
|
test_checks.py
|
rafalp_Misago/misago/core/tests/test_checks.py
|
import warnings
from django.test import TestCase
from .. import SUPPORTED_ENGINES, check_db_engine
INVALID_ENGINES = [
"django.db.backends.sqlite3",
"django.db.backends.mysql",
"django.db.backends.oracle",
]
class TestCheckDBEngine(TestCase):
def test_valid_engines(self):
"""check passes valid engines"""
with warnings.catch_warnings():
warnings.simplefilter("ignore")
for engine in SUPPORTED_ENGINES:
with self.settings(DATABASES={"default": {"ENGINE": engine}}):
errors = check_db_engine(None)
self.assertEqual(errors, [])
def test_invalid_engines(self):
"""check returns error for invalid engines"""
with warnings.catch_warnings():
warnings.simplefilter("ignore")
for engine in INVALID_ENGINES:
with self.settings(DATABASES={"default": {"ENGINE": engine}}):
errors = check_db_engine(None)
self.assertTrue(errors)
| 1,037
|
Python
|
.py
| 25
| 31.68
| 78
| 0.62251
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,984
|
test_decorators.py
|
rafalp_Misago/misago/core/tests/test_decorators.py
|
from django.test import TestCase, override_settings
from django.urls import reverse
@override_settings(ROOT_URLCONF="misago.core.testproject.urls")
class RequirePostTests(TestCase):
def test_require_POST_success(self):
"""require_POST decorator allowed POST request"""
response = self.client.post(reverse("test-require-post"))
self.assertContains(response, "Request method: POST")
def test_require_POST_fail_GET(self):
"""require_POST decorator failed on GET request"""
response = self.client.get(reverse("test-require-post"))
self.assertContains(response, "Wrong way", status_code=405)
| 646
|
Python
|
.py
| 12
| 47.916667
| 67
| 0.733756
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,985
|
test_momentjs.py
|
rafalp_Misago/misago/core/tests/test_momentjs.py
|
from django.test import override_settings
from ..momentjs import clean_language_name, get_locale_url
def test_django_language_code_is_cleaned_for_moment_js():
assert clean_language_name("en", ["en"]) == "en"
def test_two_part_django_language_code_is_cleaned_for_moment_js():
assert clean_language_name("en_us", ["en-us"]) == "en-us"
def test_two_part_django_language_code_is_fallbacked_to_single_part_code():
assert clean_language_name("en_us", ["en", "en-uk"]) == "en"
def test_django_language_code_cleanup_is_case_insensitive():
assert clean_language_name("en_US", ["en-us"]) == "en-us"
def test_django_language_code_is_cleaned_to_none_if_translation_is_not_available():
assert clean_language_name("pl", ["en"]) is None
def test_locale_url_getter_uses_passed_locales_list():
with override_settings(MISAGO_MOMENT_JS_LOCALES=["en-us"]):
assert get_locale_url("en_us", locales=["en"]).endswith("en.js")
def test_locale_url_getter_fallbacks_to_locales_setting_if_locales_kwarg_is_not_set():
with override_settings(MISAGO_MOMENT_JS_LOCALES=["en-us"]):
assert get_locale_url("en_us").endswith("en-us.js")
def test_locale_url_getter_uses_passed_static_path_template():
locale_url = get_locale_url(
"en_us", static_path_template="test/%s", locales=["en-us"]
)
assert locale_url == "test/en-us"
def test_locale_url_getter_returns_none_for_unsupported_locale():
assert get_locale_url("pl", locales=["en"]) is None
| 1,493
|
Python
|
.py
| 25
| 55.24
| 86
| 0.706694
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,986
|
progressbar.py
|
rafalp_Misago/misago/core/management/progressbar.py
|
import time
def show_progress(command, step, total, since=None):
progress = step * 100 // total
filled = progress // 2
blank = 50 - filled
template = "\r%(step)s (%(progress)s%%) [%(progressbar)s]%(estimation)s"
variables = {
"step": str(step).rjust(len(str(total))),
"progress": str(progress).rjust(3),
"progressbar": "".join(["=" * filled, " " * blank]),
"estimation": get_estimation_str(since, progress, step, total),
}
command.stdout.write(template % variables, ending="")
command.stdout.flush()
def get_estimation_str(since, progress, step, total):
if not since:
return ""
progress_float = float(step) * 100.0 / float(total)
if progress_float == 0:
return " --:--:-- est."
step_time = (time.time() - since) / progress_float
estimated_time = (100 - progress) * step_time
clock = time.strftime("%H:%M:%S", time.gmtime(estimated_time))
return " %s est." % clock
| 980
|
Python
|
.py
| 24
| 35
| 76
| 0.611814
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,987
|
models.py
|
rafalp_Misago/misago/core/testproject/models.py
|
class Model:
def __init__(self, pk, slug):
self.id, self.pk = pk, pk
self.slug = slug
| 106
|
Python
|
.py
| 4
| 20.5
| 33
| 0.539216
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,988
|
serializers.py
|
rafalp_Misago/misago/core/testproject/serializers.py
|
from rest_framework import serializers
class MockSerializer(serializers.Serializer):
id = serializers.SerializerMethodField()
class Meta:
fields = ["id"]
def get_id(self, obj):
return obj * 2
| 224
|
Python
|
.py
| 7
| 26.428571
| 45
| 0.704225
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,989
|
urls.py
|
rafalp_Misago/misago/core/testproject/urls.py
|
from django.urls import include, path
# Setup Django admin to work with Misago auth
from django.contrib import admin
from django.utils import timezone
from django.views.decorators.cache import cache_page
from django.views.decorators.http import last_modified
from django.views.i18n import JavaScriptCatalog
from . import views
from ...users.forms.auth import AdminAuthenticationForm
admin.autodiscover()
admin.site.login_form = AdminAuthenticationForm
urlpatterns = [
path("", include("social_django.urls", namespace="social")),
path("forum/", include("misago.urls", namespace="misago")),
path("django-admin/", admin.site.urls),
path(
"django-i18n.js",
cache_page(86400 * 2, key_prefix="misagojsi18n")(
last_modified(lambda req, **kw: timezone.now())(
JavaScriptCatalog.as_view(packages=["misago"])
)
),
name="django-i18n",
),
path("forum/test-pagination/", views.test_pagination, name="test-pagination"),
path(
"forum/test-pagination/<int:page>/",
views.test_pagination,
name="test-pagination",
),
path(
"forum/test-paginated-response/",
views.test_paginated_response,
name="test-paginated-response",
),
path(
"forum/test-paginated-response-data/",
views.test_paginated_response_data,
name="test-paginated-response-data",
),
path(
"forum/test-paginated-response-serializer/",
views.test_paginated_response_serializer,
name="test-paginated-response-serializer",
),
path(
"forum/test-paginated-response-data-serializer/",
views.test_paginated_response_data_serializer,
name="test-paginated-response-data-serializer",
),
path(
"forum/test-paginated-response-data-extra/",
views.test_paginated_response_data_extra,
name="test-paginated-response-data-extra",
),
path(
"forum/test-valid-slug/<slug:slug>-<int:pk>/",
views.validate_slug_view,
name="validate-slug-view",
),
path("forum/test-banned/", views.raise_misago_banned, name="raise-misago-banned"),
path("forum/test-403/", views.raise_misago_403, name="raise-misago-403"),
path("forum/test-404/", views.raise_misago_404, name="raise-misago-404"),
path("forum/test-405/", views.raise_misago_405, name="raise-misago-405"),
path(
"forum/social-auth-failed/",
views.raise_social_auth_failed,
name="raise-social-auth-failed",
),
path(
"forum/social-wrong-backend/",
views.raise_social_wrong_backend,
name="raise-social-wrong-backend",
),
path(
"forum/social-not-allowed-to-disconnect/",
views.raise_social_not_allowed_to_disconnect,
name="raise-social-not-allowed-to-disconnect",
),
path(
"forum/raise-social-auth-failed-message/",
views.raise_social_auth_failed_message,
name="raise-social-auth-failed-message",
),
path(
"forum/raise-social-auth-banned/",
views.raise_social_auth_banned,
name="raise-social-auth-banned",
),
path("test-403/", views.raise_403, name="raise-403"),
path("test-404/", views.raise_404, name="raise-404"),
path("test-redirect/", views.test_redirect, name="test-redirect"),
path("test-require-post/", views.test_require_post, name="test-require-post"),
]
| 3,443
|
Python
|
.py
| 94
| 30.138298
| 86
| 0.660389
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,990
|
urlswitherrorhandlers.py
|
rafalp_Misago/misago/core/testproject/urlswitherrorhandlers.py
|
from .urls import * # pylint: disable=wildcard-import, unused-wildcard-import
handler403 = "misago.core.testproject.views.mock_custom_403_error_page"
handler404 = "misago.core.testproject.views.mock_custom_404_error_page"
| 224
|
Python
|
.py
| 3
| 73.333333
| 78
| 0.804545
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,991
|
validators.py
|
rafalp_Misago/misago/core/testproject/validators.py
|
from rest_framework import serializers
def test_post_validator(context, data):
title_match = "casino" in data.get("title", "").lower()
post_match = "casino" in data.get("post", "").lower()
if title_match or post_match:
raise serializers.ValidationError("Don't discuss gambling!")
| 303
|
Python
|
.py
| 6
| 45.666667
| 68
| 0.70068
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,992
|
views.py
|
rafalp_Misago/misago/core/testproject/views.py
|
from django.core.exceptions import PermissionDenied
from django.http import Http404, HttpResponse
from rest_framework.decorators import api_view
from social_core.backends.github import GithubOAuth2
from social_core.exceptions import AuthFailed, NotAllowedToDisconnect, WrongBackend
from .. import errorpages
from ...users.models import Ban
from ..decorators import require_POST
from ..exceptions import Banned, SocialAuthBanned, SocialAuthFailed
from ..shortcuts import paginate, paginated_response, validate_slug
from ..views import home_redirect
from .models import Model
from .serializers import MockSerializer
def test_pagination(request, page=None):
items = range(15)
page = paginate(items, page, 5)
return HttpResponse(",".join([str(x) for x in page.object_list]))
@api_view()
def test_paginated_response(request):
data = range(100)
page = paginate(data, 2, 10)
return paginated_response(page)
@api_view()
def test_paginated_response_data(request):
data = range(100)
page = paginate(data, 2, 10)
return paginated_response(page, data=["a", "b", "c", "d", "e"])
@api_view()
def test_paginated_response_serializer(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(page, serializer=MockSerializer)
@api_view()
def test_paginated_response_data_serializer(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(
page, data=["a", "b", "c", "d"], serializer=MockSerializer
)
@api_view()
def test_paginated_response_data_extra(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(
page, data=["a", "b", "c", "d"], extra={"next": "EXTRA", "lorem": "ipsum"}
)
def validate_slug_view(request, pk, slug):
model = Model(int(pk), "eric-the-fish")
validate_slug(model, slug)
return HttpResponse("Allright!")
def raise_misago_banned(request):
ban = Ban(user_message="Banned for test!")
raise Banned(ban)
def raise_misago_403(request):
raise PermissionDenied("Misago 403")
def raise_misago_404(request):
raise Http404("Misago 404")
def raise_misago_405(request):
return errorpages.not_allowed(request)
def raise_403(request):
raise PermissionDenied()
def raise_404(request):
raise Http404()
def raise_social_auth_failed(require_POST):
raise AuthFailed(GithubOAuth2)
def raise_social_wrong_backend(request):
raise WrongBackend("facebook")
def raise_social_not_allowed_to_disconnect(request):
raise NotAllowedToDisconnect()
def raise_social_auth_failed_message(request):
raise SocialAuthFailed(GithubOAuth2, "This message will be shown to user!")
def raise_social_auth_banned(request):
ban = Ban(user_message="Banned in auth!")
raise SocialAuthBanned(GithubOAuth2, ban)
def test_redirect(request):
return home_redirect(request)
@require_POST
def test_require_post(request):
return HttpResponse("Request method: %s" % request.method)
@errorpages.shared_403_exception_handler
def mock_custom_403_error_page(request, exception):
return HttpResponse("Custom 403", status=403)
@errorpages.shared_404_exception_handler
def mock_custom_404_error_page(request, exception):
return HttpResponse("Custom 404", status=404)
| 3,320
|
Python
|
.py
| 85
| 35.4
| 83
| 0.743799
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,993
|
signals.py
|
rafalp_Misago/misago/threads/signals.py
|
from django.contrib.auth import get_user_model
from django.db import transaction
from django.db.models import Q
from django.db.models.signals import pre_delete
from django.dispatch import Signal, receiver
from django.utils.translation import pgettext
from ..categories.models import Category
from ..categories.signals import delete_category_content, move_category_content
from ..notifications.models import Notification, WatchedThread
from ..users.signals import (
anonymize_user_data,
archive_user_data,
delete_user_content,
username_changed,
)
from .anonymize import ANONYMIZABLE_EVENTS, anonymize_event, anonymize_post_last_likes
from .models import Attachment, Poll, PollVote, Post, PostEdit, PostLike, Thread
delete_post = Signal()
delete_thread = Signal()
merge_post = Signal()
merge_thread = Signal()
move_post = Signal()
move_thread = Signal()
update_thread_title = Signal()
@receiver(merge_thread)
def merge_threads(sender, **kwargs):
other_thread = kwargs["other_thread"]
other_thread.post_set.update(category=sender.category, thread=sender)
other_thread.postedit_set.update(category=sender.category, thread=sender)
other_thread.postlike_set.update(category=sender.category, thread=sender)
other_thread.subscription_set.exclude(
user__in=sender.subscription_set.values("user")
).update(category=sender.category, thread=sender)
other_thread.notification_set.update(
category=sender.category,
thread=sender,
thread_title=sender.title,
)
other_thread.watchedthread_set.update(
category=sender.category,
thread=sender,
)
@receiver(merge_post)
def merge_posts(sender, **kwargs):
other_post = kwargs["other_post"]
for user in sender.mentions.iterator(chunk_size=50):
other_post.mentions.add(user)
sender.notification_set.update(post=other_post)
@receiver(move_post)
def move_post_notifications(sender, **kwargs):
sender.notification_set.update(
category=sender.category,
thread=sender.thread,
thread_title=sender.thread.title,
)
@receiver(move_thread)
def move_thread_content(sender, **kwargs):
sender.post_set.update(category=sender.category)
sender.postedit_set.update(category=sender.category)
sender.postlike_set.update(category=sender.category)
sender.pollvote_set.update(category=sender.category)
sender.subscription_set.update(category=sender.category)
sender.notification_set.update(category=sender.category)
sender.watchedthread_set.update(category=sender.category)
Poll.objects.filter(thread=sender).update(category=sender.category)
@receiver(update_thread_title)
def change_thread_title(sender, **kwargs):
sender.notification_set.update(thread_title=sender.title)
@receiver(delete_category_content)
def delete_category_threads(sender, **kwargs):
sender.notification_set.all().delete()
sender.watchedthread_set.all().delete()
sender.subscription_set.all().delete()
sender.pollvote_set.all().delete()
sender.poll_set.all().delete()
sender.postlike_set.all().delete()
sender.thread_set.all().delete()
sender.postedit_set.all().delete()
sender.post_set.all().delete()
@receiver(move_category_content)
def move_category_threads(sender, **kwargs):
new_category = kwargs["new_category"]
sender.thread_set.update(category=new_category)
sender.post_set.filter(category=sender).update(category=new_category)
sender.postedit_set.filter(category=sender).update(category=new_category)
sender.postlike_set.filter(category=sender).update(category=new_category)
sender.poll_set.filter(category=sender).update(category=new_category)
sender.pollvote_set.update(category=new_category)
sender.subscription_set.update(category=new_category)
sender.notification_set.update(category=new_category)
sender.watchedthread_set.update(category=new_category)
@receiver(delete_user_content)
def delete_user_threads(sender, **kwargs):
recount_categories = set()
recount_threads = set()
Notification.objects.filter(
Q(thread__starter=sender) | Q(post__poster=sender)
).delete()
WatchedThread.objects.filter(thread__starter=sender).delete()
for post in sender.liked_post_set.iterator(chunk_size=50):
cleaned_likes = list(filter(lambda i: i["id"] != sender.id, post.last_likes))
if cleaned_likes != post.last_likes:
post.last_likes = cleaned_likes
post.save(update_fields=["last_likes"])
for thread in sender.thread_set.iterator(chunk_size=50):
recount_categories.add(thread.category_id)
with transaction.atomic():
thread.delete()
for post in sender.post_set.iterator(chunk_size=50):
recount_categories.add(post.category_id)
recount_threads.add(post.thread_id)
with transaction.atomic():
post.delete()
if recount_threads:
changed_threads_qs = Thread.objects.filter(id__in=recount_threads)
for thread in changed_threads_qs.iterator(chunk_size=50):
thread.synchronize()
thread.save()
if recount_categories:
for category in Category.objects.filter(id__in=recount_categories):
category.synchronize()
category.save()
@receiver(archive_user_data)
def archive_user_attachments(sender, archive=None, **kwargs):
queryset = sender.attachment_set.order_by("id")
for attachment in queryset.iterator(chunk_size=50):
archive.add_model_file(
attachment.file,
prefix=attachment.uploaded_on.strftime("%H%M%S-file"),
date=attachment.uploaded_on,
)
archive.add_model_file(
attachment.image,
prefix=attachment.uploaded_on.strftime("%H%M%S-image"),
date=attachment.uploaded_on,
)
archive.add_model_file(
attachment.thumbnail,
prefix=attachment.uploaded_on.strftime("%H%M%S-thumbnail"),
date=attachment.uploaded_on,
)
@receiver(archive_user_data)
def archive_user_posts(sender, archive=None, **kwargs):
for post in sender.post_set.order_by("id").iterator(chunk_size=50):
item_name = post.posted_on.strftime("%H%M%S-post")
archive.add_text(item_name, post.parsed, date=post.posted_on)
@receiver(archive_user_data)
def archive_user_posts_edits(sender, archive=None, **kwargs):
queryset = PostEdit.objects.filter(post__poster=sender)
for post_edit in queryset.order_by("id").iterator(chunk_size=50):
item_name = post_edit.edited_on.strftime("%H%M%S-post-edit")
archive.add_text(item_name, post_edit.edited_from, date=post_edit.edited_on)
queryset = sender.postedit_set.exclude(id__in=queryset.values("id"))
for post_edit in queryset.order_by("id").iterator(chunk_size=50):
item_name = post_edit.edited_on.strftime("%H%M%S-post-edit")
archive.add_text(item_name, post_edit.edited_from, date=post_edit.edited_on)
@receiver(archive_user_data)
def archive_user_polls(sender, archive=None, **kwargs):
for poll in sender.poll_set.order_by("id").iterator(chunk_size=50):
item_name = poll.posted_on.strftime("%H%M%S-poll")
archive.add_dict(
item_name,
{
pgettext("archived poll", "Question"): poll.question,
pgettext("archived poll", "Choices"): ", ".join(
[c["label"] for c in poll.choices]
),
},
date=poll.posted_on,
)
@receiver(anonymize_user_data)
def anonymize_user_in_events(sender, **kwargs):
queryset = Post.objects.filter(
is_event=True,
event_type__in=ANONYMIZABLE_EVENTS,
event_context__user__id=sender.id,
)
for event in queryset.iterator(chunk_size=50):
anonymize_event(sender, event)
@receiver([anonymize_user_data])
def anonymize_user_in_likes(sender, **kwargs):
for post in sender.liked_post_set.iterator(chunk_size=50):
anonymize_post_last_likes(sender, post)
@receiver([anonymize_user_data, username_changed])
def update_usernames(sender, **kwargs):
Thread.objects.filter(starter=sender).update(
starter_name=sender.username, starter_slug=sender.slug
)
Thread.objects.filter(last_poster=sender).update(
last_poster_name=sender.username, last_poster_slug=sender.slug
)
Thread.objects.filter(best_answer_marked_by=sender).update(
best_answer_marked_by_name=sender.username,
best_answer_marked_by_slug=sender.slug,
)
Post.objects.filter(poster=sender).update(poster_name=sender.username)
Post.objects.filter(last_editor=sender).update(
last_editor_name=sender.username, last_editor_slug=sender.slug
)
PostEdit.objects.filter(editor=sender).update(
editor_name=sender.username, editor_slug=sender.slug
)
PostLike.objects.filter(liker=sender).update(
liker_name=sender.username, liker_slug=sender.slug
)
Attachment.objects.filter(uploader=sender).update(
uploader_name=sender.username, uploader_slug=sender.slug
)
Poll.objects.filter(poster=sender).update(
poster_name=sender.username, poster_slug=sender.slug
)
PollVote.objects.filter(voter=sender).update(
voter_name=sender.username, voter_slug=sender.slug
)
@receiver(pre_delete, sender=get_user_model())
def remove_private_threads_without_participants(sender, **kwargs):
threads_qs = kwargs["instance"].privatethread_set
for thread in threads_qs.iterator(chunk_size=50):
if thread.participants.count() <= 1:
with transaction.atomic():
thread.delete()
| 9,747
|
Python
|
.py
| 221
| 37.755656
| 86
| 0.711555
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,994
|
filters.py
|
rafalp_Misago/misago/threads/filters.py
|
from dataclasses import dataclass
from django.http import HttpRequest
from django.db.models import F, Q, QuerySet
from django.utils.translation import pgettext_lazy
from ..readtracker.models import ReadCategory, ReadThread
from ..readtracker.readtime import get_default_read_time
class ThreadsFilter:
name: str
url: str
def __call__(self, queryset: QuerySet) -> QuerySet:
return queryset
def as_choice(self, base_url: str, active: bool) -> "ThreadsFilterChoice":
return ThreadsFilterChoice(
name=self.name,
url=self.url,
absolute_url=f"{base_url}{self.url}/",
active=active,
filter=self,
)
class UnreadThreadsFilter(ThreadsFilter):
name: str = pgettext_lazy("threads filter", "Unread threads")
url: str = "unread"
request: HttpRequest
def __init__(self, request: HttpRequest):
self.request = request
def __call__(self, queryset: QuerySet) -> QuerySet:
if self.request.user.is_anonymous:
return queryset.none()
read_time = get_default_read_time(self.request.settings, self.request.user)
queryset = queryset.filter(
last_post_on__gt=read_time,
)
categories_read_times = ReadCategory.objects.filter(
user=self.request.user
).values_list("category_id", "read_time")
for category_id, read_time in categories_read_times:
queryset = queryset.exclude(
category_id=category_id, last_post_on__lte=read_time
)
queryset = queryset.exclude(
id__in=ReadThread.objects.filter(
user=self.request.user,
read_time__gte=F("thread__last_post_on"),
).values("thread_id")
)
return queryset
class MyThreadsFilter(ThreadsFilter):
name: str = pgettext_lazy("threads filter", "My threads")
url: str = "my"
request: HttpRequest
def __init__(self, request: HttpRequest):
self.request = request
def __call__(self, queryset: QuerySet) -> QuerySet:
if self.request.user.is_authenticated:
return queryset.filter(starter=self.request.user)
return queryset.none()
class UnapprovedThreadsFilter(ThreadsFilter):
name: str = pgettext_lazy("threads filter", "Unapproved threads")
url: str = "unapproved"
request: HttpRequest
def __init__(self, request: HttpRequest):
self.request = request
def __call__(self, queryset: QuerySet) -> QuerySet:
return queryset.filter(Q(is_unapproved=True) | Q(has_unapproved_posts=True))
@dataclass(frozen=True)
class ThreadsFilterChoice:
name: str
url: str
absolute_url: str
active: bool
filter: MyThreadsFilter
| 2,788
|
Python
|
.py
| 71
| 31.478873
| 84
| 0.658355
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,995
|
enums.py
|
rafalp_Misago/misago/threads/enums.py
|
from enum import IntEnum, StrEnum
from django.utils.translation import pgettext_lazy
class ThreadWeight(IntEnum):
NOT_PINNED = 0
PINNED_IN_CATEGORY = 1
PINNED_GLOBALLY = 2
class ThreadsListsPolling(IntEnum):
DISABLED = 0
ENABLED_FOR_USERS = 1
ENABLED = 2
@classmethod
def get_choices(cls):
return (
(
cls.ENABLED,
pgettext_lazy(
"threads lists polling choice",
"Enable for both signed-in users and guests",
),
),
(
cls.ENABLED_FOR_USERS,
pgettext_lazy(
"category lists polling choice", "Enable for signed-in users"
),
),
(
cls.DISABLED,
pgettext_lazy("category lists polling choice", "Disable"),
),
)
| 915
|
Python
|
.py
| 31
| 18.387097
| 81
| 0.513667
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,996
|
paginator.py
|
rafalp_Misago/misago/threads/paginator.py
|
from math import ceil
from django.core.paginator import Paginator
class PostsPaginator(Paginator):
"""Paginator that makes last item on page repeat as first item on next page."""
def __init__(self, object_list, per_page, orphans=0, allow_empty_first_page=True):
per_page = int(per_page) - 1
if orphans:
orphans += 1
super().__init__(object_list, per_page, orphans, allow_empty_first_page)
def page(self, number):
"""returns a Page object for the given 1-based page number."""
number = self.validate_number(number)
bottom = (number - 1) * self.per_page
top = bottom + self.per_page
if top + self.orphans >= self.count:
top = self.count
if top < self.count:
top += 1
return self._get_page(self.object_list[bottom:top], number, self)
class ThreadRepliesPaginator(Paginator):
def get_item_page(self, offset: int) -> int:
item_page = ceil((offset + 1) / self.per_page)
return min(item_page, self.num_pages)
| 1,057
|
Python
|
.py
| 23
| 38.217391
| 86
| 0.63778
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,997
|
test.py
|
rafalp_Misago/misago/threads/test.py
|
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.utils import timezone
from ..acl.test import patch_user_acl
from ..categories.models import Category
from ..core.utils import slugify
from ..users.test import create_test_user
from .checksums import update_post_checksum
from .models import Poll, Post, Thread
default_category_acl = {
"can_see": 1,
"can_browse": 1,
"can_see_all_threads": 1,
"can_see_own_threads": 0,
"can_hide_threads": 0,
"can_approve_content": 0,
"can_edit_posts": 0,
"can_hide_posts": 0,
"can_hide_own_posts": 0,
"can_merge_threads": 0,
"can_close_threads": 0,
}
def patch_category_acl(acl_patch=None):
def patch_acl(_, user_acl):
category = Category.objects.get(slug="first-category")
category_acl = user_acl["categories"][category.id]
category_acl.update(default_category_acl)
if acl_patch:
category_acl.update(acl_patch)
cleanup_patched_acl(user_acl, category_acl, category)
return patch_user_acl(patch_acl)
def patch_other_user_category_acl(acl_patch=None):
def patch_acl(user, user_acl):
if user.slug != "other_user":
return
category = Category.objects.get(slug="first-category")
category_acl = user_acl["categories"][category.id]
category_acl.update(default_category_acl)
if acl_patch:
category_acl.update(acl_patch)
cleanup_patched_acl(user_acl, category_acl, category)
return patch_user_acl(patch_acl)
def patch_other_category_acl(acl_patch=None):
def patch_acl(_, user_acl):
src_category = Category.objects.get(slug="first-category")
category_acl = user_acl["categories"][src_category.id].copy()
dst_category = Category.objects.get(slug="other-category")
user_acl["categories"][dst_category.id] = category_acl
category_acl.update(default_category_acl)
if acl_patch:
category_acl.update(acl_patch)
cleanup_patched_acl(user_acl, category_acl, dst_category)
return patch_user_acl(patch_acl)
def patch_private_threads_acl(acl_patch=None):
def patch_acl(_, user_acl):
category = Category.objects.private_threads()
category_acl = user_acl["categories"][category.id]
category_acl.update(default_category_acl)
if acl_patch:
category_acl.update(acl_patch)
cleanup_patched_acl(user_acl, category_acl, category)
return patch_user_acl(patch_acl)
def other_user_cant_use_private_threads(user, user_acl):
if user.slug == "other-user":
user_acl.update({"can_use_private_threads": False})
def create_category_acl_patch(category_slug, acl_patch):
def created_category_acl_patch(_, user_acl):
category = Category.objects.get(slug=category_slug)
category_acl = user_acl["categories"].get(category.id, {})
category_acl.update(default_category_acl)
if acl_patch:
category_acl.update(acl_patch)
cleanup_patched_acl(user_acl, category_acl, category)
return created_category_acl_patch
def cleanup_patched_acl(user_acl, category_acl, category):
visible_categories = user_acl["visible_categories"]
browseable_categories = user_acl["browseable_categories"]
if not category_acl["can_see"] and category.id in visible_categories:
visible_categories.remove(category.id)
if not category_acl["can_see"] and category.id in browseable_categories:
browseable_categories.remove(category.id)
if not category_acl["can_browse"] and category.id in browseable_categories:
browseable_categories.remove(category.id)
if category_acl["can_see"] and category.id not in visible_categories:
visible_categories.append(category.id)
if category_acl["can_browse"] and category.id not in browseable_categories:
browseable_categories.append(category.id)
User = get_user_model()
def post_thread(
category,
title="Test thread",
poster="Tester",
is_global=False,
is_pinned=False,
is_unapproved=False,
is_hidden=False,
is_closed=False,
started_on=None,
):
started_on = started_on or timezone.now()
kwargs = {
"category": category,
"title": title,
"slug": slugify(title),
"started_on": started_on,
"last_post_on": started_on,
"is_unapproved": is_unapproved,
"is_hidden": is_hidden,
"is_closed": is_closed,
}
if is_global:
kwargs["weight"] = 2
elif is_pinned:
kwargs["weight"] = 1
try:
kwargs.update(
{
"starter": poster,
"starter_name": poster.username,
"starter_slug": poster.slug,
"last_poster": poster,
"last_poster_name": poster.username,
"last_poster_slug": poster.slug,
}
)
except AttributeError:
kwargs.update(
{
"starter_name": poster,
"starter_slug": slugify(poster),
"last_poster_name": poster,
"last_poster_slug": slugify(poster),
}
)
thread = Thread.objects.create(**kwargs)
reply_thread(
thread,
poster=poster,
posted_on=started_on,
is_hidden=is_hidden,
is_unapproved=is_unapproved,
)
return thread
def reply_thread(
thread,
poster="Tester",
message="I am test message",
is_unapproved=False,
is_hidden=False,
is_event=False,
is_protected=False,
has_reports=False,
has_open_reports=False,
posted_on=None,
):
posted_on = posted_on or thread.last_post_on + timedelta(minutes=5)
kwargs = {
"category": thread.category,
"thread": thread,
"original": message,
"parsed": message,
"checksum": "nope",
"posted_on": posted_on,
"updated_on": posted_on,
"is_event": is_event,
"is_unapproved": is_unapproved,
"is_hidden": is_hidden,
"is_protected": is_protected,
"has_reports": has_reports,
"has_open_reports": has_open_reports,
}
try:
kwargs.update({"poster": poster, "poster_name": poster.username})
except AttributeError:
kwargs.update({"poster_name": poster})
post = Post.objects.create(**kwargs)
update_post_checksum(post)
post.save()
thread.synchronize()
thread.save()
thread.category.synchronize()
thread.category.save()
return post
def post_poll(thread, poster):
poll = Poll.objects.create(
category=thread.category,
thread=thread,
poster=poster,
poster_name=poster.username,
poster_slug=poster.slug,
question="Lorem ipsum dolor met?",
choices=[
{"hash": "aaaaaaaaaaaa", "label": "Alpha", "votes": 1},
{"hash": "bbbbbbbbbbbb", "label": "Beta", "votes": 0},
{"hash": "gggggggggggg", "label": "Gamma", "votes": 2},
{"hash": "dddddddddddd", "label": "Delta", "votes": 1},
],
allowed_choices=2,
votes=4,
)
# one user voted for Alpha choice
try:
user = User.objects.get(slug="user")
except User.DoesNotExist:
user = create_test_user("User", "user@example.com")
poll.pollvote_set.create(
category=thread.category,
thread=thread,
voter=user,
voter_name=user.username,
voter_slug=user.slug,
choice_hash="aaaaaaaaaaaa",
)
# test user voted on third and last choices
poll.pollvote_set.create(
category=thread.category,
thread=thread,
voter=poster,
voter_name=poster.username,
voter_slug=poster.slug,
choice_hash="gggggggggggg",
)
poll.pollvote_set.create(
category=thread.category,
thread=thread,
voter=poster,
voter_name=poster.username,
voter_slug=poster.slug,
choice_hash="dddddddddddd",
)
# somebody else voted on third option before being deleted
poll.pollvote_set.create(
category=thread.category,
thread=thread,
voter_name="deleted",
voter_slug="deleted",
choice_hash="gggggggggggg",
)
return poll
def like_post(post, liker=None, username=None):
if not post.last_likes:
post.last_likes = []
if liker:
like = post.postlike_set.create(
category=post.category,
thread=post.thread,
liker=liker,
liker_name=liker.username,
liker_slug=liker.slug,
)
post.last_likes = [
{"id": liker.id, "username": liker.username}
] + post.last_likes
else:
like = post.postlike_set.create(
category=post.category,
thread=post.thread,
liker_name=username,
liker_slug=slugify(username),
)
post.last_likes = [{"id": None, "username": username}] + post.last_likes
post.likes += 1
post.save()
return like
| 9,165
|
Python
|
.py
| 264
| 26.996212
| 80
| 0.627899
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,998
|
filtersearch.py
|
rafalp_Misago/misago/threads/filtersearch.py
|
from django.utils.module_loading import import_string
from .. import hooks
from ..conf import settings
filters_list = settings.MISAGO_POST_SEARCH_FILTERS
SEARCH_FILTERS = list(map(import_string, filters_list))
def filter_search(search, filters=None):
filters = filters or SEARCH_FILTERS
for search_filter in filters:
search = search_filter(search) or search
for search_filter in hooks.post_search_filters:
search = search_filter(search) or search
return search
| 499
|
Python
|
.py
| 12
| 37.416667
| 55
| 0.765073
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,999
|
anonymize.py
|
rafalp_Misago/misago/threads/anonymize.py
|
from django.urls import reverse
ANONYMIZABLE_EVENTS = (
"added_participant",
"changed_owner",
"owner_left",
"removed_owner",
"participant_left",
"removed_participant",
)
def anonymize_event(user, event):
if event.event_type not in ANONYMIZABLE_EVENTS:
raise ValueError('event of type "%s" can\'t be ananymized' % event.event_type)
event.event_context = {
"user": {"id": None, "username": user.username, "url": reverse("misago:index")}
}
event.save(update_fields=["event_context"])
def anonymize_post_last_likes(user, post):
cleaned_likes = []
for like in post.last_likes:
if like["id"] == user.id:
cleaned_likes.append({"id": None, "username": user.username})
else:
cleaned_likes.append(like)
if cleaned_likes != post.last_likes:
post.last_likes = cleaned_likes
post.save(update_fields=["last_likes"])
| 933
|
Python
|
.py
| 26
| 29.846154
| 87
| 0.646667
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|