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,800
|
test_paginate_queryset.py
|
rafalp_Misago/misago/pagination/tests/test_paginate_queryset.py
|
from unittest.mock import Mock
from ...notifications.models import Notification
from ..cursor import paginate_queryset
def test_pagination_returns_all_items(notifications):
request = Mock(GET={})
page = paginate_queryset(request, Notification.objects, 20, "id")
assert len(page.items) == 15
assert not page.has_next
assert not page.has_previous
assert page.next_cursor is None
assert page.previous_cursor is None
items_verbs = [item.verb for item in page.items]
assert items_verbs == [f"test_{i}" for i in range(15)]
def test_pagination_returns_all_items_in_reverse_order(notifications):
request = Mock(GET={})
page = paginate_queryset(request, Notification.objects, 20, "-id")
assert len(page.items) == 15
assert not page.has_next
assert not page.has_previous
assert page.next_cursor is None
assert page.previous_cursor is None
items_verbs = [item.verb for item in page.items]
assert items_verbs == [f"test_{i}" for i in reversed(range(15))]
def test_pagination_returns_no_items(db):
request = Mock(GET={})
page = paginate_queryset(request, Notification.objects, 20, "id")
assert len(page.items) == 0
assert not page.has_next
assert not page.has_previous
assert page.next_cursor is None
assert page.previous_cursor is None
def test_pagination_returns_firsts_and_previous_cursor_for_first_page(notifications):
request = Mock(GET={})
page = paginate_queryset(request, Notification.objects, 5, "id")
assert len(page.items) == 5
assert page.next_cursor == notifications[4]
assert page.previous_cursor is None
def test_pagination_returns_firsts_and_previous_cursor_for_second_page(notifications):
request = Mock(GET={"cursor": notifications[:5][-1]})
page = paginate_queryset(request, Notification.objects, 5, "id")
assert len(page.items) == 5
assert page.next_cursor == notifications[9]
assert page.previous_cursor is None
def test_pagination_returns_firsts_and_previous_cursor_for_last_page(notifications):
request = Mock(GET={"cursor": notifications[:10][-1]})
page = paginate_queryset(request, Notification.objects, 5, "id")
assert len(page.items) == 5
assert page.next_cursor is None
assert page.previous_cursor == notifications[4]
def test_pagination_returns_first_items_up_to_limit(notifications):
request = Mock(GET={})
page = paginate_queryset(request, Notification.objects, 4, "id")
assert len(page.items) == 4
assert page.has_next
assert not page.has_previous
assert page.next_cursor == notifications[3]
assert page.previous_cursor is None
items_verbs = [item.verb for item in page.items]
assert items_verbs == ["test_0", "test_1", "test_2", "test_3"]
def test_pagination_returns_first_items_up_to_limit_in_reverse_order(
notifications,
):
request = Mock(GET={})
page = paginate_queryset(request, Notification.objects, 4, "-id")
assert len(page.items) == 4
assert page.has_next
assert not page.has_previous
assert page.next_cursor == notifications[11]
assert page.previous_cursor is None
items_verbs = [item.verb for item in page.items]
assert items_verbs == ["test_14", "test_13", "test_12", "test_11"]
| 3,276
|
Python
|
.py
| 71
| 41.408451
| 86
| 0.718829
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,801
|
test_paginate_queryset_with_cursor.py
|
rafalp_Misago/misago/pagination/tests/test_paginate_queryset_with_cursor.py
|
from unittest.mock import Mock
import pytest
from ...notifications.models import Notification
from ..cursor import EmptyPageError, paginate_queryset
def test_pagination_with_cursor_returns_items_up_to_limit(notifications):
request = Mock(GET={"cursor": notifications[4]})
page = paginate_queryset(request, Notification.objects, 4, "id")
assert len(page.items) == 4
assert page.has_next
assert page.has_previous
assert page.next_cursor == notifications[8]
assert page.previous_cursor == notifications[0]
items_verbs = [item.verb for item in page.items]
assert items_verbs == ["test_5", "test_6", "test_7", "test_8"]
def test_pagination_with_cursor_returns_last_items(notifications):
request = Mock(GET={"cursor": notifications[9]})
page = paginate_queryset(request, Notification.objects, 10, "id")
assert len(page.items) == 5
assert not page.has_next
assert page.has_previous
assert not page.next_cursor
assert not page.previous_cursor
items_verbs = [item.verb for item in page.items]
assert items_verbs == ["test_10", "test_11", "test_12", "test_13", "test_14"]
def test_pagination_with_cursor_returns_items_up_to_limit_in_reverse_order(
notifications,
):
request = Mock(GET={"cursor": notifications[9]})
page = paginate_queryset(request, Notification.objects, 4, "-id")
assert len(page.items) == 4
assert page.has_next
assert page.has_previous
assert page.next_cursor == notifications[5]
assert page.previous_cursor == notifications[13]
items_verbs = [item.verb for item in page.items]
assert items_verbs == ["test_8", "test_7", "test_6", "test_5"]
def test_pagination_with_cursor_returns_last_items_in_reverse_order(notifications):
request = Mock(GET={"cursor": notifications[4]})
page = paginate_queryset(request, Notification.objects, 10, "-id")
assert len(page.items) == 4
assert not page.has_next
assert page.has_previous
assert not page.next_cursor
assert page.previous_cursor == notifications[14]
items_verbs = [item.verb for item in page.items]
assert items_verbs == ["test_3", "test_2", "test_1", "test_0"]
def test_pagination_with_cursor_raises_empty_page_error_without_last_page_cursor(
notifications,
):
request = Mock(GET={"cursor": notifications[-1] * 2})
with pytest.raises(EmptyPageError) as exc_info:
paginate_queryset(request, Notification.objects, 20, "id")
assert exc_info.value.last_cursor == None
def test_pagination_with_cursor_raises_empty_page_error_with_last_page_cursor(
notifications,
):
request = Mock(GET={"cursor": notifications[-1] * 2})
with pytest.raises(EmptyPageError) as exc_info:
paginate_queryset(request, Notification.objects, 5, "id")
assert exc_info.value.last_cursor == notifications[9]
def test_pagination_with_cursor_raises_empty_page_error_with_last_page_cursor_for_reversed_queryset(
notifications,
):
request = Mock(GET={"cursor": 1})
with pytest.raises(EmptyPageError) as exc_info:
paginate_queryset(request, Notification.objects, 5, "-id")
assert exc_info.value.last_cursor == notifications[5]
| 3,195
|
Python
|
.py
| 67
| 42.955224
| 100
| 0.718528
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,802
|
test_query_values_validation.py
|
rafalp_Misago/misago/pagination/tests/test_query_values_validation.py
|
from unittest.mock import Mock
import pytest
from ...notifications.models import Notification
from ..cursor import PaginationError, paginate_queryset
def test_pagination_raises_error_if_cursor_is_not_a_number(db):
request = Mock(GET={"cursor": "str"})
with pytest.raises(PaginationError) as excinfo:
paginate_queryset(request, Notification.objects, 100, "id")
assert "must be a positive integer" in str(excinfo)
def test_pagination_raises_error_if_cursor_is_zero(db):
request = Mock(GET={"cursor": 0})
with pytest.raises(PaginationError) as excinfo:
paginate_queryset(request, Notification.objects, 100, "id")
assert "must be a positive integer" in str(excinfo)
def test_pagination_raises_error_if_cursor_is_negative(db):
request = Mock(GET={"cursor": -1})
with pytest.raises(PaginationError) as excinfo:
paginate_queryset(request, Notification.objects, 100, "id")
assert "must be a positive integer" in str(excinfo)
| 991
|
Python
|
.py
| 19
| 47.263158
| 67
| 0.745303
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,803
|
apps.py
|
rafalp_Misago/misago/metatags/apps.py
|
from django.apps import AppConfig
class MisagoMetatagsConfig(AppConfig):
name = "misago.metatags"
label = "misago_metatags"
verbose_name = "Misago Metatags"
| 171
|
Python
|
.py
| 5
| 30.4
| 38
| 0.762195
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,804
|
metatags.py
|
rafalp_Misago/misago/metatags/metatags.py
|
from django.conf import settings as dj_settings
from django.http import HttpRequest
from django.templatetags.static import static
from .hooks import get_default_metatags_hook, get_forum_index_metatags_hook
from .metatag import MetaTag
__all__ = ["MetaTag", "get_default_metatags", "get_forum_index_metatags"]
def get_default_metatags(request: HttpRequest) -> dict[str, MetaTag]:
return get_default_metatags_hook(_get_default_metatags_action, request)
def _get_default_metatags_action(request: HttpRequest) -> dict[str, MetaTag]:
settings = request.settings
metatags = {
"og:site_name": MetaTag(property="og:site_name", content=settings.forum_name),
"og:type": MetaTag(property="og:type", content="website"),
"twitter:card": MetaTag(name="twitter:card", content="summary"),
}
og_image = request.settings.get("og_image")
if og_image["value"]:
metatags.update(
{
"image": MetaTag(
property="og:image",
name="twitter:image",
content=request.build_absolute_uri(og_image["value"]),
),
"image:width": MetaTag(
property="og:image:width", content=og_image["width"]
),
"image:height": MetaTag(
property="og:image:height", content=og_image["height"]
),
}
)
else:
og_image_url = request.build_absolute_uri(
static(dj_settings.MISAGO_DEFAULT_OG_IMAGE)
)
metatags.update(
{
"image": MetaTag(
property="og:image",
name="twitter:image",
content=og_image_url,
),
"image:width": MetaTag(
property="og:image:width",
content=dj_settings.MISAGO_DEFAULT_OG_IMAGE_WIDTH,
),
"image:height": MetaTag(
property="og:image:height",
content=dj_settings.MISAGO_DEFAULT_OG_IMAGE_HEIGHT,
),
}
)
return metatags
def get_forum_index_metatags(request: HttpRequest) -> dict[str, MetaTag]:
return get_forum_index_metatags_hook(_get_forum_index_metatags_action, request)
def _get_forum_index_metatags_action(request: HttpRequest) -> dict[str, MetaTag]:
metatags = get_default_metatags(request)
if request.settings.index_title:
metatags["title"] = MetaTag(
property="og:title",
name="twitter:title",
content=request.settings.index_title,
)
if request.settings.index_meta_description:
metatags["description"] = MetaTag(
property="og:description",
name="twitter:description",
content=request.settings.index_meta_description,
)
if request.settings.forum_address:
metatags["url"] = MetaTag(
property="og:url",
name="twitter:url",
content=request.settings.forum_address,
)
return metatags
| 3,139
|
Python
|
.py
| 77
| 29.454545
| 86
| 0.582457
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,805
|
metatag.py
|
rafalp_Misago/misago/metatags/metatag.py
|
import html
from dataclasses import dataclass
@dataclass(frozen=True)
class MetaTag:
content: str | int
name: str | None = None
property: str | None = None
itemprop: str | None = None
def get_attrs(self) -> dict[str, str]:
attrs: dict[str, str] = {}
if self.name:
attrs["name"] = str(self.name)
if self.property:
attrs["property"] = str(self.property)
if self.itemprop:
attrs["itemprop"] = str(self.itemprop)
attrs["content"] = str(self.content)
return attrs
def as_html(self):
attrs: dict[str, str] = self.get_attrs()
attrs_html = [f'{name}="{html.escape(value)}"' for name, value in attrs.items()]
return f"<meta {' '.join(attrs_html)}>"
| 777
|
Python
|
.py
| 22
| 28.090909
| 88
| 0.593333
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,806
|
test_default_metatags.py
|
rafalp_Misago/misago/metatags/tests/test_default_metatags.py
|
from django.conf import settings
from ...conf.dynamicsettings import DynamicSettings
from ...conf.models import Setting
from ..metatags import get_default_metatags
def test_get_default_metatags_returns_default_metatags_with_default_og_image(
rf, dynamic_settings
):
request = rf.get("/")
request.settings = dynamic_settings
metatags = {
key: value.get_attrs() for key, value in get_default_metatags(request).items()
}
assert metatags == {
"og:site_name": {
"property": "og:site_name",
"content": dynamic_settings.forum_name,
},
"og:type": {
"property": "og:type",
"content": "website",
},
"twitter:card": {
"name": "twitter:card",
"content": "summary",
},
"image": {
"property": "og:image",
"name": "twitter:image",
"content": f"http://testserver/static/{settings.MISAGO_DEFAULT_OG_IMAGE}",
},
"image:width": {
"property": "og:image:width",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_WIDTH),
},
"image:height": {
"property": "og:image:height",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_HEIGHT),
},
}
def test_get_default_metatags_returns_default_metatags_with_custom_og_image(
db, rf, cache_versions
):
Setting.objects.filter(setting="og_image").update(
image="custom-image.jpg", image_width=600, image_height=300
)
request = rf.get("/")
request.settings = DynamicSettings(cache_versions)
metatags = {
key: value.get_attrs() for key, value in get_default_metatags(request).items()
}
assert metatags == {
"og:site_name": {
"property": "og:site_name",
"content": request.settings.forum_name,
},
"og:type": {
"property": "og:type",
"content": "website",
},
"twitter:card": {
"name": "twitter:card",
"content": "summary",
},
"image": {
"property": "og:image",
"name": "twitter:image",
"content": "http://testserver/media/custom-image.jpg",
},
"image:width": {
"property": "og:image:width",
"content": "600",
},
"image:height": {
"property": "og:image:height",
"content": "300",
},
}
| 2,492
|
Python
|
.py
| 77
| 23.545455
| 86
| 0.543867
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,807
|
test_forum_index_metatags.py
|
rafalp_Misago/misago/metatags/tests/test_forum_index_metatags.py
|
from django.conf import settings
from ...conf.test import override_dynamic_settings
from ..metatags import get_forum_index_metatags
@override_dynamic_settings(index_title="Index Title")
def test_get_forum_index_metatags_includes_index_title_if_set(rf, dynamic_settings):
request = rf.get("/")
request.settings = dynamic_settings
metatags = {
key: value.get_attrs()
for key, value in get_forum_index_metatags(request).items()
}
assert metatags == {
"og:site_name": {
"property": "og:site_name",
"content": dynamic_settings.forum_name,
},
"og:type": {
"property": "og:type",
"content": "website",
},
"twitter:card": {
"name": "twitter:card",
"content": "summary",
},
"image": {
"property": "og:image",
"name": "twitter:image",
"content": f"http://testserver/static/{settings.MISAGO_DEFAULT_OG_IMAGE}",
},
"image:width": {
"property": "og:image:width",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_WIDTH),
},
"image:height": {
"property": "og:image:height",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_HEIGHT),
},
"title": {
"name": "twitter:title",
"property": "og:title",
"content": "Index Title",
},
}
@override_dynamic_settings(index_meta_description="Meta Description")
def test_get_forum_index_metatags_includes_index_meta_description_if_set(
rf, dynamic_settings
):
request = rf.get("/")
request.settings = dynamic_settings
metatags = {
key: value.get_attrs()
for key, value in get_forum_index_metatags(request).items()
}
assert metatags == {
"og:site_name": {
"property": "og:site_name",
"content": dynamic_settings.forum_name,
},
"og:type": {
"property": "og:type",
"content": "website",
},
"twitter:card": {
"name": "twitter:card",
"content": "summary",
},
"image": {
"property": "og:image",
"name": "twitter:image",
"content": f"http://testserver/static/{settings.MISAGO_DEFAULT_OG_IMAGE}",
},
"image:width": {
"property": "og:image:width",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_WIDTH),
},
"image:height": {
"property": "og:image:height",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_HEIGHT),
},
"description": {
"name": "twitter:description",
"property": "og:description",
"content": "Meta Description",
},
}
@override_dynamic_settings(forum_address="http://example.com")
def test_get_forum_index_metatags_includes_forum_address_if_set(rf, dynamic_settings):
request = rf.get("/")
request.settings = dynamic_settings
metatags = {
key: value.get_attrs()
for key, value in get_forum_index_metatags(request).items()
}
assert metatags == {
"og:site_name": {
"property": "og:site_name",
"content": dynamic_settings.forum_name,
},
"og:type": {
"property": "og:type",
"content": "website",
},
"twitter:card": {
"name": "twitter:card",
"content": "summary",
},
"image": {
"property": "og:image",
"name": "twitter:image",
"content": f"http://testserver/static/{settings.MISAGO_DEFAULT_OG_IMAGE}",
},
"image:width": {
"property": "og:image:width",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_WIDTH),
},
"image:height": {
"property": "og:image:height",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_HEIGHT),
},
"url": {
"name": "twitter:url",
"property": "og:url",
"content": "http://example.com",
},
}
def test_get_forum_index_metatags_includes_default_metatags(rf, dynamic_settings):
request = rf.get("/")
request.settings = dynamic_settings
metatags = {
key: value.get_attrs()
for key, value in get_forum_index_metatags(request).items()
}
assert metatags == {
"og:site_name": {
"property": "og:site_name",
"content": dynamic_settings.forum_name,
},
"og:type": {
"property": "og:type",
"content": "website",
},
"twitter:card": {
"name": "twitter:card",
"content": "summary",
},
"image": {
"property": "og:image",
"name": "twitter:image",
"content": f"http://testserver/static/{settings.MISAGO_DEFAULT_OG_IMAGE}",
},
"image:width": {
"property": "og:image:width",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_WIDTH),
},
"image:height": {
"property": "og:image:height",
"content": str(settings.MISAGO_DEFAULT_OG_IMAGE_HEIGHT),
},
}
| 5,304
|
Python
|
.py
| 159
| 23.899371
| 86
| 0.530811
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,808
|
get_forum_index_metatags.py
|
rafalp_Misago/misago/metatags/hooks/get_forum_index_metatags.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
from ..metatag import MetaTag
class GetForumIndexMetatagsHookAction(Protocol):
"""
A standard Misago function used to get metatags for the forum index page.
# Arguments
## `request: HttpRequest`
The request object.
# Return value
A Python `dict` with metatags to include in the response HTML.
"""
def __call__(self, request: HttpRequest) -> dict[str, MetaTag]: ...
class GetForumIndexMetatagsHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetForumIndexMetatagsHookAction`
A standard Misago function used to get metatags for the forum index page.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
# Return value
A Python `dict` with metatags to include in the response HTML.
"""
def __call__(
self,
action: GetForumIndexMetatagsHookAction,
request: HttpRequest,
) -> dict[str, MetaTag]: ...
class GetForumIndexMetatagsHook(
FilterHook[GetForumIndexMetatagsHookAction, GetForumIndexMetatagsHookFilter]
):
"""
This hook wraps the standard function that Misago uses to get metatags for
the forum index page.
# Example
The code below implements a custom filter function that adds a custom
metatag to the forum index page:
```python
from django.http import HttpRequest
from misago.metatags.hooks import get_forum_index_metatags_hook
from misago.metatags.metatag import MetaTag
@get_forum_index_metatags_hook.append_filter
def include_custom_metatag(action, request: HttpRequest) -> dict[str, MetaTag]:
metatags = action(request)
metatags["custom"] = MetaTag(
name="og:custom",
property="twitter:custom",
itemprop="custom",
content="custom content",
)
return metatags
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetForumIndexMetatagsHookAction,
request: HttpRequest,
) -> dict[str, MetaTag]:
return super().__call__(action, request)
get_forum_index_metatags_hook = GetForumIndexMetatagsHook()
| 2,361
|
Python
|
.py
| 64
| 30.765625
| 83
| 0.696689
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,809
|
get_default_metatags.py
|
rafalp_Misago/misago/metatags/hooks/get_default_metatags.py
|
from typing import Protocol
from django.http import HttpRequest
from ...plugins.hooks import FilterHook
from ..metatag import MetaTag
class GetDefaultMetatagsHookAction(Protocol):
"""
A standard Misago function used to get default metatags for all pages.
# Arguments
## `request: HttpRequest`
The request object.
# Return value
A Python `dict` with metatags to include in the response HTML.
"""
def __call__(self, request: HttpRequest) -> dict[str, MetaTag]: ...
class GetDefaultMetatagsHookFilter(Protocol):
"""
A function implemented by a plugin that can be registered in this hook.
# Arguments
## `action: GetDefaultMetatagsHookAction`
A standard Misago function used to get default metatags for all pages.
See the [action](#action) section for details.
## `request: HttpRequest`
The request object.
# Return value
A Python `dict` with metatags to include in the response HTML.
"""
def __call__(
self,
action: GetDefaultMetatagsHookAction,
request: HttpRequest,
) -> dict[str, MetaTag]: ...
class GetDefaultMetatagsHook(
FilterHook[GetDefaultMetatagsHookAction, GetDefaultMetatagsHookFilter]
):
"""
This hook wraps the standard function that Misago uses to get default
metatags for all pages.
# Example
The code below implements a custom filter function that adds a custom
metatag to all pages:
```python
from django.http import HttpRequest
from misago.metatags.hooks import get_default_metatags_hook
from misago.metatags.metatag import MetaTag
@get_default_metatags_hook.append_filter
def include_custom_metatag(action, request: HttpRequest) -> dict[str, MetaTag]:
metatags = action(request)
metatags["custom"] = MetaTag(
name="og:custom",
property="twitter:custom",
itemprop="custom",
content="custom content",
)
return metatags
```
"""
__slots__ = FilterHook.__slots__
def __call__(
self,
action: GetDefaultMetatagsHookAction,
request: HttpRequest,
) -> dict[str, MetaTag]:
return super().__call__(action, request)
get_default_metatags_hook = GetDefaultMetatagsHook()
| 2,302
|
Python
|
.py
| 64
| 29.84375
| 83
| 0.692203
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,810
|
users.py
|
rafalp_Misago/misago/faker/users.py
|
import hashlib
import random
from django.contrib.auth import get_user_model
from django.utils.crypto import get_random_string
from ..users.bans import ban_user
from ..users.test import create_test_user
from .utils import retry_on_db_error
User = get_user_model()
AVATAR_SIZES = (400, 200, 100)
GRAVATAR_URL = "https://www.gravatar.com/avatar/%s?s=%s&d=retro"
PASSWORD = "password"
@retry_on_db_error
def get_fake_user(fake, rank=None, requires_activation=User.ACTIVATION_NONE):
username = get_fake_username(fake)
email = fake.email()
return create_test_user(
username,
email.lower(),
PASSWORD,
avatars=get_fake_avatars(email),
rank=rank,
requires_activation=requires_activation,
)
def get_fake_banned_user(fake, rank=None):
user = get_fake_user(fake, rank=rank)
ban_user(user)
return user
def get_fake_inactive_user(fake, rank=None):
return get_fake_user(fake, rank=rank, requires_activation=User.ACTIVATION_USER)
def get_fake_admin_activated_user(fake, rank=None):
return get_fake_user(fake, rank=rank, requires_activation=User.ACTIVATION_ADMIN)
def get_fake_deleted_user(fake, rank=None):
user = get_fake_user(fake, rank=rank)
user.is_active = False
user.save(update_fields=["is_active"])
return user
def get_fake_username(fake):
possible_usernames = [
fake.first_name(),
fake.last_name(),
fake.name().replace(" ", ""),
fake.user_name(),
get_random_string(random.randint(4, 8)),
]
return random.choice(possible_usernames)
def get_fake_avatars(email):
email_hash = hashlib.md5(email.lower().encode()).hexdigest()
return [
{"size": size, "url": GRAVATAR_URL % (email_hash, size)}
for size in AVATAR_SIZES
]
| 1,807
|
Python
|
.py
| 51
| 30.509804
| 84
| 0.695276
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,811
|
colors.py
|
rafalp_Misago/misago/faker/colors.py
|
# Tailwind colors palette, 500 - 900 shades
# https://tailwindcss.com/docs/customizing-colors
COLORS = [
# Slate
"#64748b",
"#475569",
"#334155",
"#1e293b",
"#0f172a",
# Gray
"#6b7280",
"#4b5563",
"#374151",
"#1f2937",
"#111827",
# Zinc
"#71717a",
"#52525b",
"#3f3f46",
"#27272a",
"#18181b",
# Neutral
"#737373",
"#525252",
"#404040",
"#262626",
"#171717",
# Stone
"#78716c",
"#57534e",
"#44403c",
"#292524",
"#1c1917",
# Red
"#ef4444",
"#dc2626",
"#b91c1c",
"#991b1b",
"#7f1d1d",
# Orange
"#f97316",
"#ea580c",
"#c2410c",
"#9a3412",
"#7c2d12",
# Amber
"#f59e0b",
"#d97706",
"#b45309",
"#92400e",
"78350f",
# Yellow
"#eab308",
"#ca8a04",
"#a16207",
"#854d0e",
"#713f12",
# Lime
"#84cc16",
"#65a30d",
"#4d7c0f",
"#3f6212",
"#365314",
# Green
"#22c55e",
"#16a34a",
"#15803d",
"#166534",
"#14532d",
# Emerald
"#10b981",
"#059669",
"#047857",
"#065f46",
"#064e3b",
# Teal
"#14b8a6",
"#0d9488",
"#0f766e",
"#115e59",
"#134e4a",
# Cyan
"#06b6d4",
"#0891b2",
"#0e7490",
"#155e75",
"#164e63",
# Sky
"#0ea5e9",
"#0284c7",
"#0369a1",
"#075985",
"#0c4a6e",
# Blue
"#3b82f6",
"#2563eb",
"#1d4ed8",
"#1e40af",
"#1e3a8a",
# Indigo
"#6366f1",
"#4f46e5",
"#4338ca",
"#3730a3",
"#312e81",
# Violet
"#8b5cf6",
"#7c3aed",
"#6d28d9",
"#5b21b6",
"#4c1d95",
# Purple
"#a855f7",
"#9333ea",
"#7e22ce",
"#6b21a8",
"#581c87",
# Fuchsia
"#d946ef",
"#c026d3",
"#a21caf",
"#86198f",
"#701a75",
# Pink
"#ec4899",
"#db2777",
"#be185d",
"#9d174d",
"#831843",
# Rose
"#f43f5e",
"#e11d48",
"#be123c",
"#9f1239",
"#881337",
]
| 2,019
|
Python
|
.py
| 136
| 9.963235
| 49
| 0.450345
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,812
|
englishcorpus.py
|
rafalp_Misago/misago/faker/englishcorpus.py
|
import os
import random
PHRASES_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "phrases.txt")
class EnglishCorpus:
def __init__(self, phrases_file=PHRASES_FILE, min_length=None, max_length=None):
self._countdown = 0
self._previous = None
self.phrases = []
with open(phrases_file, "r") as f:
for phrase in [l.strip() for l in f.readlines()]:
if min_length and len(phrase) < min_length:
continue
if max_length and len(phrase) > max_length:
continue
self.phrases.append(phrase)
def _countdown_to_shuffle(self):
self._countdown -= 1
if self._countdown < 0:
self._countdown = random.randint(500, 1000)
self.shuffle()
def __len__(self):
return len(self.phrases)
def shuffle(self):
random.shuffle(self.phrases)
def random_sentence(self):
self._countdown_to_shuffle()
choice = None
while not choice or choice == self._previous:
choice = random.choice(self.phrases)
self._previous = choice
return choice
def random_sentences(self, no):
self._countdown_to_shuffle()
max_no = len(self) - no - 1
start = random.randint(0, max_no)
sentences = self.phrases[start : (start + no)]
random.shuffle(sentences)
return sentences
| 1,451
|
Python
|
.py
| 38
| 28.605263
| 86
| 0.589707
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,813
|
apps.py
|
rafalp_Misago/misago/faker/apps.py
|
from django.apps import AppConfig
class MisagoFakerConfig(AppConfig):
name = "misago.faker"
label = "misago_faker"
verbose_name = "Misago Test Data Generator"
| 173
|
Python
|
.py
| 5
| 30.8
| 47
| 0.753012
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,814
|
bans.py
|
rafalp_Misago/misago/faker/bans.py
|
import random
from datetime import timedelta
from django.utils import timezone
from ..users.models import Ban
def get_fake_username_ban(fake):
ban = _create_base_ban(fake, Ban.USERNAME)
banned_value = fake.first_name()
if random.randint(0, 100) < 31:
banned_value = "%s*" % banned_value
elif random.randint(0, 100) < 31:
banned_value = "*%s" % banned_value
elif random.randint(0, 100) < 31:
banned_value = list(banned_value)
banned_value.insert(random.randint(0, len(banned_value) - 1), "*")
banned_value = "".join(banned_value)
ban.banned_value = banned_value
ban.save()
return ban
def get_fake_email_ban(fake):
ban = _create_base_ban(fake, Ban.EMAIL)
if random.randint(0, 100) < 35:
ban.banned_value = "*@%s" % fake.domain_name()
else:
ban.banned_value = fake.email()
ban.save()
return ban
def get_fake_ip_ban(fake):
ban = _create_base_ban(fake, Ban.IP)
if random.randint(0, 1):
banned_value = fake.ipv4()
if random.randint(0, 100) < 35:
banned_value = banned_value.split(".")
banned_value = ".".join(banned_value[: random.randint(1, 3)])
banned_value = "%s.*" % banned_value
elif random.randint(0, 100) < 35:
banned_value = banned_value.split(".")
banned_value = ".".join(banned_value[random.randint(1, 3) :])
banned_value = "*.%s" % banned_value
elif random.randint(0, 100) < 35:
banned_value = banned_value.split(".")
banned_value[random.randint(0, 3)] = "*"
banned_value = ".".join(banned_value)
else:
banned_value = fake.ipv6()
if random.randint(0, 100) < 35:
banned_value = banned_value.split(":")
banned_value = ":".join(banned_value[: random.randint(1, 7)])
banned_value = "%s:*" % banned_value
elif random.randint(0, 100) < 35:
banned_value = banned_value.split(":")
banned_value = ":".join(banned_value[: random.randint(1, 7)])
banned_value = "*:%s" % banned_value
elif random.randint(0, 100) < 35:
banned_value = banned_value.split(":")
banned_value[random.randint(0, 7)] = "*"
banned_value = ":".join(banned_value)
ban.banned_value = banned_value
ban.save()
return ban
def _create_base_ban(fake, ban_type):
ban = Ban(check_type=ban_type)
if random.randint(0, 10) == 0:
ban.user_message = fake.sentence()
if random.randint(0, 10) == 0:
ban.staff_message = fake.sentence()
if random.randint(0, 1):
# Lets make ban temporary
ban_length = timedelta(days=random.randint(0, 300))
if random.randint(0, 1):
ban.valid_until = timezone.now().date() - ban_length
else:
ban.valid_until = timezone.now().date() + ban_length
return ban
| 2,961
|
Python
|
.py
| 73
| 32.369863
| 74
| 0.58842
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,815
|
utils.py
|
rafalp_Misago/misago/faker/utils.py
|
from django.db import IntegrityError
from django.db.transaction import TransactionManagementError
def retry_on_db_error(f):
def wrapper(*args, **kwargs):
try:
return f(*args, **kwargs)
except (IntegrityError, TransactionManagementError):
return wrapper(*args, **kwargs)
return wrapper
| 336
|
Python
|
.py
| 9
| 30.666667
| 60
| 0.700617
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,816
|
posts.py
|
rafalp_Misago/misago/faker/posts.py
|
import random
from django.utils import timezone
from ..threads.checksums import update_post_checksum
from ..threads.models import Post
from .englishcorpus import EnglishCorpus
from .users import get_fake_username
PLACEKITTEN_URL = "https://dummyimage.com/g/%s/%s"
corpus = EnglishCorpus()
def get_fake_post(fake, thread, poster=None):
original, parsed = get_fake_post_content(fake)
posted_on = timezone.now()
post = Post.objects.create(
category=thread.category,
thread=thread,
poster=poster,
poster_name=poster.username if poster else get_fake_username(fake),
original=original,
parsed=parsed,
posted_on=posted_on,
updated_on=posted_on,
)
update_post_checksum(post)
post.save(update_fields=["checksum"])
return post
def get_fake_unapproved_post(fake, thread, poster=None):
post = get_fake_post(fake, thread, poster)
post.is_unapproved = True
post.save(update_fields=["is_unapproved"])
return post
def get_fake_hidden_post(fake, thread, poster=None, hidden_by=None):
post = get_fake_post(fake, thread, poster)
post.is_hidden = True
if hidden_by:
post.hidden_by = hidden_by
post.hidden_by_name = hidden_by.username
post.hidden_by_slug = hidden_by.slug
else:
post.hidden_by_name = fake.first_name()
post.hidden_by_slug = post.hidden_by_name.lower()
post.save(
update_fields=["is_unapproved", "hidden_by", "hidden_by_name", "hidden_by_slug"]
)
return post
def get_fake_post_content(fake):
raw = []
parsed = []
if random.randint(0, 100) > 90:
paragraphs_to_make = random.randint(1, 20)
else:
paragraphs_to_make = random.randint(1, 5)
for _ in range(paragraphs_to_make):
if random.randint(0, 100) > 95:
cat_width = random.randint(1, 16) * random.choice([100, 90, 80])
cat_height = random.randint(1, 12) * random.choice([100, 90, 80])
cat_url = PLACEKITTEN_URL % (cat_width, cat_height)
raw.append("!(%s)" % cat_url)
parsed.append('<p><img src="%s" alt=""/></p>' % cat_url)
else:
if random.randint(0, 100) > 95:
sentences_to_make = random.randint(1, 20)
else:
sentences_to_make = random.randint(1, 7)
raw.append(" ".join(corpus.random_sentences(sentences_to_make)))
parsed.append("<p>%s</p>" % raw[-1])
return "\n\n".join(raw), "\n".join(parsed)
| 2,542
|
Python
|
.py
| 65
| 31.923077
| 88
| 0.634216
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,817
|
threads.py
|
rafalp_Misago/misago/faker/threads.py
|
from django.utils import timezone
from ..threads.models import Thread
from .englishcorpus import EnglishCorpus
from .posts import get_fake_hidden_post, get_fake_post, get_fake_unapproved_post
corpus_short = EnglishCorpus(max_length=150)
def get_fake_thread(fake, category, starter=None):
thread = _create_base_thread(fake, category)
thread.first_post = get_fake_post(fake, thread, starter)
thread.save(update_fields=["first_post"])
return thread
def get_fake_closed_thread(fake, category, starter=None):
thread = get_fake_thread(fake, category)
thread.is_closed = True
thread.save(update_fields=["is_closed"])
return thread
def get_fake_hidden_thread(fake, category, starter=None, hidden_by=None):
thread = _create_base_thread(fake, category)
thread.first_post = get_fake_hidden_post(fake, thread, starter, hidden_by)
thread.is_hidden = True
thread.save(update_fields=["first_post", "is_hidden"])
return thread
def get_fake_unapproved_thread(fake, category, starter=None):
thread = _create_base_thread(fake, category)
thread.first_post = get_fake_unapproved_post(fake, thread, starter)
thread.is_unapproved = True
thread.save(update_fields=["first_post", "is_unapproved"])
return thread
def _create_base_thread(fake, category):
started_on = timezone.now()
thread = Thread(
category=category,
started_on=started_on,
starter_name="-",
starter_slug="-",
last_post_on=started_on,
last_poster_name="-",
last_poster_slug="-",
replies=0,
)
# Sometimes thread ends with slug being set to empty string
while not thread.slug:
thread.set_title(corpus_short.random_sentence())
thread.save()
return thread
| 1,780
|
Python
|
.py
| 44
| 35.204545
| 80
| 0.70889
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,818
|
categories.py
|
rafalp_Misago/misago/faker/categories.py
|
import random
from ..categories.models import Category, RoleCategoryACL
from ..permissions.copy import copy_category_permissions
from .colors import COLORS
def fake_category(fake, parent, copy_permissions=None):
category = Category()
category.set_name(fake_category_name(fake))
if random.randint(1, 100) > 50:
category.description = fake_category_description(fake)
if random.randint(1, 100) > 15:
category.color = random.choice(COLORS)
category.insert_at(parent, position="last-child", save=True)
if copy_permissions:
copy_category_permissions(copy_permissions, category)
copy_acl_to_fake_category(copy_permissions, category)
return category
def fake_closed_category(fake, parent, copy_permissions=None):
category = fake_category(fake, parent, copy_permissions)
category.is_closed = True
category.save(update_fields=["is_closed"])
return category
def copy_acl_to_fake_category(source, category):
copied_acls = []
for acl in source.category_role_set.all():
copied_acls.append(
RoleCategoryACL(
role_id=acl.role_id,
category=category,
category_role_id=acl.category_role_id,
)
)
if copied_acls:
RoleCategoryACL.objects.bulk_create(copied_acls)
def fake_category_name(fake):
if random.randint(1, 100) > 75:
return fake.catch_phrase().title()
return fake.street_name()
def fake_category_description(fake):
if random.randint(1, 100) > 80:
return "\r\n".join(fake.paragraphs())
return fake.paragraph()
| 1,629
|
Python
|
.py
| 41
| 33.02439
| 64
| 0.692357
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,819
|
conftest.py
|
rafalp_Misago/misago/faker/tests/conftest.py
|
import pytest
from faker import Factory
@pytest.fixture
def fake():
return Factory.create()
| 98
|
Python
|
.py
| 5
| 17.4
| 27
| 0.802198
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,820
|
test_create_fake_users_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_users_command.py
|
from io import StringIO
from django.contrib.auth import get_user_model
from django.core.management import call_command
from ..management.commands import createfakeusers
User = get_user_model()
def test_management_command_creates_fake_users(db):
call_command(createfakeusers.Command(), stdout=StringIO())
assert User.objects.exists()
| 346
|
Python
|
.py
| 8
| 40.625
| 62
| 0.813814
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,821
|
test_create_fake_bans_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_bans_command.py
|
from io import StringIO
from django.core.management import call_command
from ...cache.test import assert_invalidates_cache
from ...users import BANS_CACHE
from ...users.models import Ban
from ..management.commands import createfakebans
def test_management_command_creates_fake_bans(db):
call_command(createfakebans.Command(), stdout=StringIO())
assert Ban.objects.exists()
def test_management_command_invalidates_bans_cache(db):
with assert_invalidates_cache(BANS_CACHE):
call_command(createfakebans.Command(), stdout=StringIO())
| 556
|
Python
|
.py
| 12
| 43.166667
| 65
| 0.795539
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,822
|
test_create_fake_threads_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_threads_command.py
|
from io import StringIO
from django.core.management import call_command
from ...threads.models import Thread
from ..management.commands import createfakethreads
def test_management_command_creates_fake_threads(db):
call_command(createfakethreads.Command(), stdout=StringIO())
assert Thread.objects.exists()
| 319
|
Python
|
.py
| 7
| 42.857143
| 64
| 0.821429
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,823
|
test_fake_posts.py
|
rafalp_Misago/misago/faker/tests/test_fake_posts.py
|
import pytest
from ..posts import (
get_fake_hidden_post,
get_fake_post,
get_fake_post_content,
get_fake_unapproved_post,
)
from ..threads import get_fake_thread
@pytest.fixture
def thread(fake, default_category):
return get_fake_thread(fake, default_category)
def test_fake_post_can_be_created(fake, thread):
assert get_fake_post(fake, thread)
def test_fake_post_belongs_to_same_category_as_its_thread(fake, thread):
post = get_fake_post(fake, thread)
assert post.category == thread.category
def test_fake_post_is_created_with_guest_poster(fake, thread):
post = get_fake_post(fake, thread)
assert post.poster is None
def test_fake_post_is_created_with_guest_poster_has_poster_name(fake, thread):
post = get_fake_post(fake, thread)
assert post.poster_name
def test_fake_post_is_created_with_specified_poster(fake, thread, user):
post = get_fake_post(fake, thread, user)
assert post.poster == user
assert post.poster_name == user.username
def test_fake_post_is_created_with_valid_checksum(fake, thread):
post = get_fake_post(fake, thread)
assert post.is_valid
def test_fake_post_is_created_with_different_content_every_time(fake, thread):
post_a = get_fake_post(fake, thread)
post_b = get_fake_post(fake, thread)
assert post_a.original != post_b.original
assert post_a.parsed != post_b.parsed
def test_fake_hidden_post_can_be_created(fake, thread):
post = get_fake_hidden_post(fake, thread)
assert post.is_hidden
def test_fake_unapproved_post_can_be_created(fake, thread):
post = get_fake_unapproved_post(fake, thread)
assert post.is_unapproved
def test_fake_post_content_can_be_created(fake):
original, parsed = get_fake_post_content(fake)
assert original
assert parsed
def test_different_fake_post_content_is_created_every_time(fake):
original_a, parsed_a = get_fake_post_content(fake)
original_b, parsed_b = get_fake_post_content(fake)
assert original_a != original_b
assert parsed_a != parsed_b
| 2,051
|
Python
|
.py
| 49
| 37.734694
| 78
| 0.737987
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,824
|
test_fake_users.py
|
rafalp_Misago/misago/faker/tests/test_fake_users.py
|
from ...users.bans import get_user_ban
from ...users.models import Rank
from ..users import (
PASSWORD,
get_fake_admin_activated_user,
get_fake_banned_user,
get_fake_deleted_user,
get_fake_inactive_user,
get_fake_user,
get_fake_username,
)
def test_fake_user_can_be_created(db, fake):
assert get_fake_user(fake)
def test_fake_user_is_created_with_predictable_password(db, fake):
user = get_fake_user(fake)
assert user.check_password(PASSWORD)
def test_fake_user_is_created_with_test_avatars(db, fake):
user = get_fake_user(fake)
assert user.avatars
def test_new_fake_user_avatars_are_created_for_every_new_user(db, fake):
user_a = get_fake_user(fake)
user_b = get_fake_user(fake)
assert user_a.avatars != user_b.avatars
def test_fake_user_is_created_with_explicit_rank(db, fake):
rank = Rank.objects.create(name="Test Rank")
user = get_fake_user(fake, rank)
assert user.rank is rank
def test_banned_fake_user_can_be_created(db, cache_versions, fake):
user = get_fake_banned_user(fake)
assert get_user_ban(user, cache_versions)
def test_inactivate_fake_user_can_be_created(db, fake):
user = get_fake_inactive_user(fake)
assert user.requires_activation
def test_admin_activated_fake_user_can_be_created(db, fake):
user = get_fake_admin_activated_user(fake)
assert user.requires_activation
def test_deleted_fake_user_can_be_created(db, fake):
user = get_fake_deleted_user(fake)
assert not user.is_active
def test_fake_username_can_be_created(fake):
assert get_fake_username(fake)
def test_different_fake_username_is_used_every_time(fake):
fake_usernames = [get_fake_username(fake) for i in range(5)]
assert len(fake_usernames) == len(set(fake_usernames))
| 1,790
|
Python
|
.py
| 44
| 36.545455
| 72
| 0.732599
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,825
|
test_create_fake_watched_threads_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_watched_threads_command.py
|
from io import StringIO
from django.core.management import call_command
from ...notifications.models import WatchedThread
from ..management.commands import createfakewatchedthreads
def test_management_command_creates_watched_threads(
user, other_user, thread, other_thread
):
call_command(createfakewatchedthreads.Command(), stdout=StringIO())
assert WatchedThread.objects.count() == 4 # 2 users x 2 threads
| 425
|
Python
|
.py
| 9
| 44.444444
| 71
| 0.808252
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,826
|
test_create_fake_categories_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_categories_command.py
|
from io import StringIO
from django.core.management import call_command
from ...acl import ACL_CACHE
from ...cache.test import assert_invalidates_cache
from ..management.commands import createfakecategories
def test_management_command_creates_fake_categories(root_category):
call_command(createfakecategories.Command(), categories=5, stdout=StringIO())
root_category.refresh_from_db()
assert root_category.get_descendant_count() == 6 # 5 fakes + 1 default
def test_management_command_updates_categories_tree_after_creation(root_category):
call_command(createfakecategories.Command(), categories=5, stdout=StringIO())
root_category.refresh_from_db()
assert root_category.rght == root_category.lft + 13 # 6 child items
def test_management_command_creates_categories_at_specified_level(default_category):
call_command(
createfakecategories.Command(),
categories=5,
level=2,
stdout=StringIO(),
)
default_category.refresh_from_db()
assert default_category.get_descendant_count() == 5
def test_management_command_copies_default_category_acl(default_category):
call_command(
createfakecategories.Command(),
categories=5,
level=1,
stdout=StringIO(),
)
default_category.refresh_from_db()
default_acls_count = default_category.category_role_set.count()
for fake_category in default_category.get_descendants():
assert fake_category.category_role_set.count() == default_acls_count
def test_management_command_invalidates_acl_cache(db):
with assert_invalidates_cache(ACL_CACHE):
call_command(createfakecategories.Command(), categories=5, stdout=StringIO())
| 1,705
|
Python
|
.py
| 36
| 41.944444
| 85
| 0.747884
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,827
|
test_fake_categories.py
|
rafalp_Misago/misago/faker/tests/test_fake_categories.py
|
from ..categories import (
fake_category,
fake_category_description,
fake_category_name,
fake_closed_category,
)
from ...permissions.models import CategoryGroupPermission
def test_fake_category_can_be_created(fake, root_category):
assert fake_category(fake, root_category)
def test_fake_category_is_created_with_specified_parent(fake, default_category):
category = fake_category(fake, default_category)
assert category.parent == default_category
def test_fake_category_can_be_created_with_copy_of_other_category_permissions(
fake, root_category, default_category
):
category = fake_category(fake, root_category, copy_permissions=default_category)
for acl in default_category.category_role_set.all():
category.category_role_set.get(role=acl.role, category_role=acl.category_role)
assert CategoryGroupPermission.objects.filter(category=category).exists()
def test_fake_closed_category_can_be_created(fake, root_category):
category = fake_closed_category(fake, root_category)
assert category.is_closed
def test_fake_category_name_can_be_created(fake):
assert fake_category_name(fake)
def test_different_fake_category_name_is_created_every_time(fake):
fake_names = [fake_category_name(fake) for i in range(5)]
assert len(fake_names) == len(set(fake_names))
def test_fake_category_description_can_be_created(fake):
assert fake_category_description(fake)
def test_different_fake_category_description_is_created_every_time(fake):
fake_descriptions = [fake_category_description(fake) for i in range(5)]
assert len(fake_descriptions) == len(set(fake_descriptions))
| 1,657
|
Python
|
.py
| 32
| 47.625
| 86
| 0.77301
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,828
|
test_englishcorpus.py
|
rafalp_Misago/misago/faker/tests/test_englishcorpus.py
|
from ..englishcorpus import EnglishCorpus
def test_corpus_has_length():
corpus = EnglishCorpus()
assert corpus
def test_corpus_can_be_shuffled():
corpus = EnglishCorpus()
corpus.shuffle()
def test_corpus_can_be_limited_to_phrases_shorter_than_specified():
corpus = EnglishCorpus(max_length=100)
assert corpus
def test_corpus_can_be_limited_to_phrases_longer_than_specified():
corpus = EnglishCorpus(min_length=100)
assert corpus
def test_corpus_produces_random_sequence():
corpus = EnglishCorpus()
choices = [corpus.random_sentence() for _ in range(2)]
assert len(choices) == len(set(choices))
def test_corpus_produces_list_of_random_sentences():
corpus = EnglishCorpus()
assert len(corpus.random_sentences(5)) == 5
| 780
|
Python
|
.py
| 20
| 34.8
| 67
| 0.740642
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,829
|
test_fake_bans.py
|
rafalp_Misago/misago/faker/tests/test_fake_bans.py
|
from ...users.models import Ban
from ..bans import get_fake_email_ban, get_fake_ip_ban, get_fake_username_ban
def test_fake_username_ban_can_be_created(db, fake):
assert get_fake_username_ban(fake)
Ban.objects.get(check_type=Ban.USERNAME)
def test_fake_email_ban_can_be_created(db, fake):
assert get_fake_email_ban(fake)
Ban.objects.get(check_type=Ban.EMAIL)
def test_fake_ip_ban_can_be_created(db, fake):
assert get_fake_ip_ban(fake)
Ban.objects.get(check_type=Ban.IP)
| 500
|
Python
|
.py
| 11
| 41.727273
| 77
| 0.743271
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,830
|
test_create_fake_history_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_history_command.py
|
from datetime import timedelta
from io import StringIO
import pytest
from django.contrib.auth import get_user_model
from django.core.management import call_command
from django.utils import timezone
from ...categories.models import Category
from ...threads.models import Post, Thread
from ...users.models import Rank
from ..management.commands import createfakehistory
from ..threads import get_fake_thread
from ..users import get_fake_admin_activated_user, get_fake_inactive_user, get_fake_user
User = get_user_model()
@pytest.fixture
def command(db):
return createfakehistory.Command(stdout=StringIO())
@pytest.fixture
def date():
return timezone.now()
def test_management_command_has_no_errors(db):
call_command(createfakehistory.Command(), max_actions=3, stdout=StringIO())
def test_management_command_creates_fake_user(fake, command, date):
ranks = list(Rank.objects.all())
command.create_fake_user(fake, date, ranks)
assert User.objects.exists()
def test_fake_user_join_date_is_overridden_by_command(fake, command, date):
ranks = list(Rank.objects.all())
command.create_fake_user(fake, date, ranks)
user = User.objects.order_by("-pk").last()
assert user.joined_on == date
def test_fake_user_rank_is_one_from_the_choices(fake, command, date):
ranks = list(Rank.objects.all())
command.create_fake_user(fake, date, ranks)
user = User.objects.order_by("-pk").last()
assert user.rank in ranks
def test_none_is_returned_for_random_user_if_no_users_exist(command, date):
user = command.get_random_user(date)
assert user is None
def test_users_created_after_given_date_are_excluded_from_random_user_pick(
command, date, other_user
):
other_user.joined_on = timezone.now()
other_user.save()
user = command.get_random_user(date)
assert user is None
def test_inactive_users_are_excluded_from_random_user_pick(fake, command):
get_fake_admin_activated_user(fake)
get_fake_inactive_user(fake)
user = command.get_random_user(timezone.now())
assert user is None
def test_random_user_pick_returns_random_user(fake, command):
valid_choices = [get_fake_user(fake) for _ in range(5)]
user = command.get_random_user(timezone.now())
assert user in valid_choices
def test_management_command_creates_fake_thread(fake, command, date):
categories = list(Category.objects.all_categories())
command.create_fake_thread(fake, date, categories)
assert Thread.objects.exists()
def test_fake_thread_start_date_is_overridden_by_command(fake, command, date):
categories = list(Category.objects.all_categories())
command.create_fake_thread(fake, date, categories)
thread = Thread.objects.last()
assert thread.started_on == date
def test_fake_thread_was_created_in_one_of_valid_categories(fake, command, date):
categories = list(Category.objects.all_categories())
command.create_fake_thread(fake, date, categories)
thread = Thread.objects.last()
assert thread.category in categories
def test_none_is_returned_for_random_thread_if_no_threads_exist(command, date):
thread = command.get_random_thread(date)
assert thread is None
def test_threads_created_after_given_date_are_excluded_from_random_thread_pick(
fake, command, date, default_category
):
get_fake_thread(fake, default_category)
thread = command.get_random_thread(date)
assert thread is None
def test_random_thread_pick_returns_random_thread(fake, command, default_category):
valid_choices = [get_fake_thread(fake, default_category) for _ in range(5)]
thread = command.get_random_thread(timezone.now())
assert thread in valid_choices
def test_management_command_creates_fake_post(fake, command, default_category):
thread = get_fake_thread(fake, default_category)
command.create_fake_post(fake, timezone.now())
assert thread.post_set.count() == 2
def test_fake_post_creation_date_is_overridden_by_command(
fake, command, date, default_category
):
thread = get_fake_thread(fake, default_category)
thread.started_on -= timedelta(days=1)
thread.save()
command.create_fake_post(fake, date)
post = thread.post_set.last()
assert post.posted_on == date
def test_fake_post_is_not_created_if_no_threads_exist(fake, command, date):
command.create_fake_post(fake, date)
assert not Post.objects.exists()
def test_management_command_synchronizes_threads(fake, command, date, default_category):
command.create_fake_thread(fake, date, [default_category])
command.synchronize_threads()
def test_management_command_synchronizes_categories(
fake, command, date, default_category
):
command.create_fake_thread(fake, date, [default_category])
command.synchronize_threads()
command.synchronize_categories()
| 4,823
|
Python
|
.py
| 106
| 41.556604
| 88
| 0.754551
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,831
|
test_fake_threads.py
|
rafalp_Misago/misago/faker/tests/test_fake_threads.py
|
from ..threads import (
get_fake_closed_thread,
get_fake_hidden_thread,
get_fake_thread,
get_fake_unapproved_thread,
)
def test_fake_thread_can_be_created(fake, default_category):
assert get_fake_thread(fake, default_category)
def test_fake_thread_is_created_with_opening_post(fake, default_category):
thread = get_fake_thread(fake, default_category)
assert thread.first_post
def test_fake_thread_is_created_with_guest_starter(fake, default_category):
thread = get_fake_thread(fake, default_category)
assert thread.first_post.poster is None
def test_fake_thread_is_created_with_specified_starter(fake, default_category, user):
thread = get_fake_thread(fake, default_category, user)
assert thread.first_post.poster == user
assert thread.first_post.poster_name == user.username
def test_fake_thread_is_created_in_specified_category(fake, default_category):
thread = get_fake_thread(fake, default_category)
assert thread.category == default_category
assert thread.first_post.category == default_category
def test_fake_closed_thread_can_be_created(fake, default_category):
thread = get_fake_closed_thread(fake, default_category)
assert thread.is_closed
def test_fake_hidden_thread_can_be_created(fake, default_category):
thread = get_fake_hidden_thread(fake, default_category)
assert thread.is_hidden
assert thread.first_post.is_hidden
def test_fake_unapproved_thread_can_be_created(fake, default_category):
thread = get_fake_unapproved_thread(fake, default_category)
assert thread.is_unapproved
assert thread.first_post.is_unapproved
def test_different_fake_thread_title_is_used_every_time(fake, default_category):
thread_a = get_fake_thread(fake, default_category)
thread_b = get_fake_thread(fake, default_category)
assert thread_a.title != thread_b.title
| 1,876
|
Python
|
.py
| 37
| 46.405405
| 85
| 0.766063
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,832
|
test_create_fake_posts_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_posts_command.py
|
from io import StringIO
from django.core.management import call_command
from ...threads.models import Post
from ..management.commands import createfakeposts
from ..threads import get_fake_thread
def test_management_command_creates_fake_threads(fake, default_category):
thread = get_fake_thread(fake, default_category)
call_command(createfakeposts.Command(), stdout=StringIO())
assert Post.objects.exclude(pk=thread.first_post.pk).exists()
| 455
|
Python
|
.py
| 9
| 47.777778
| 73
| 0.80543
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,833
|
test_create_fake_followers_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_followers_command.py
|
from io import StringIO
from django.core.management import call_command
from ..management.commands import createfakefollowers
from ..users import get_fake_user
def test_management_command_creates_fake_followers_for_two_users(user, other_user):
call_command(createfakefollowers.Command(), stdout=StringIO())
def test_management_command_creates_fake_followers_for_multiple_users(db, fake):
[get_fake_user(fake) for i in range(10)]
call_command(createfakefollowers.Command(), stdout=StringIO())
def test_management_command_displays_error_if_no_users_exist(db):
stderr = StringIO()
call_command(createfakefollowers.Command(), stderr=stderr)
stderr.seek(0)
assert stderr.read()
def test_management_command_displays_error_if_only_one_user_exist(user):
stderr = StringIO()
call_command(createfakefollowers.Command(), stderr=stderr)
stderr.seek(0)
assert stderr.read()
| 915
|
Python
|
.py
| 19
| 44.315789
| 83
| 0.778781
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,834
|
test_create_fake_notifications_command.py
|
rafalp_Misago/misago/faker/tests/test_create_fake_notifications_command.py
|
from io import StringIO
from django.core.management import call_command
from ...notifications.models import Notification
from ..management.commands import createfakenotifications
def test_management_command_creates_notifications(
user, other_user, thread, reply, other_thread
):
call_command(createfakenotifications.Command(), stdout=StringIO())
assert Notification.objects.count() == 6 # 2 users x 3 posts
| 424
|
Python
|
.py
| 9
| 44.333333
| 70
| 0.805353
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,835
|
createfakefollowers.py
|
rafalp_Misago/misago/faker/management/commands/createfakefollowers.py
|
import random
import time
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from ....core.management.progressbar import show_progress
User = get_user_model()
class Command(BaseCommand):
help = "Adds random followers for testing purposes"
def handle(self, *args, **options):
total_users = User.objects.count()
if total_users < 2:
self.stderr.write(
"At least two users must exist in the databse in order for "
"fake followers creation to be possible.\n"
)
return
message = "Adding fake followers to %s users...\n"
self.stdout.write(message % total_users)
total_followers = 0
processed_count = 0
start_time = time.time()
show_progress(self, processed_count, total_users)
for user in User.objects.iterator(chunk_size=50):
user.followed_by.clear()
followers_to_create = random.randint(0, total_users - 1)
while followers_to_create:
# There's 34% chance we'll skip follower creation
if random.randint(0, 100) > 34:
new_follower = (
User.objects.exclude(pk=user.pk).order_by("?")[:1].first()
)
if not user.is_following(new_follower):
user.follows.add(new_follower)
followers_to_create -= 1
processed_count += 1
show_progress(self, processed_count, total_users)
self.stdout.write("\nSynchronizing users...")
for user in User.objects.iterator(chunk_size=50):
user.followers = user.followed_by.count()
user.following = user.follows.count()
user.save(update_fields=["followers", "following"])
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\nSuccessfully added %s fake followers in %s"
self.stdout.write(message % (total_followers, total_humanized))
| 2,120
|
Python
|
.py
| 45
| 35.888889
| 82
| 0.605429
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,836
|
createfakeusers.py
|
rafalp_Misago/misago/faker/management/commands/createfakeusers.py
|
import random
import time
from django.core.management.base import BaseCommand
from faker import Factory
from ....core.management.progressbar import show_progress
from ....users.models import Rank
from ...users import (
get_fake_inactive_user,
get_fake_admin_activated_user,
get_fake_banned_user,
get_fake_user,
)
class Command(BaseCommand):
help = "Creates fake users for dev and testing purposes."
def add_arguments(self, parser):
parser.add_argument(
"users", help="number of users to create", nargs="?", type=int, default=5
)
def handle(self, *args, **options):
items_to_create = options["users"]
fake = Factory.create()
ranks = list(Rank.objects.all())
message = "Creating %s fake user accounts...\n"
self.stdout.write(message % items_to_create)
created_count = 0
start_time = time.time()
show_progress(self, created_count, items_to_create)
while created_count < items_to_create:
rank = random.choice(ranks)
if random.randint(0, 100) > 80:
get_fake_inactive_user(fake, rank)
elif random.randint(0, 100) > 90:
get_fake_admin_activated_user(fake, rank)
elif random.randint(0, 100) > 90:
get_fake_banned_user(fake, rank)
else:
get_fake_user(fake, rank)
created_count += 1
show_progress(self, created_count, items_to_create, start_time)
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\n\nSuccessfully created %s fake user accounts in %s"
self.stdout.write(message % (created_count, total_humanized))
| 1,791
|
Python
|
.py
| 43
| 33.209302
| 85
| 0.630184
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,837
|
createfakebans.py
|
rafalp_Misago/misago/faker/management/commands/createfakebans.py
|
import random
import sys
from django.core.management.base import BaseCommand
from faker import Factory
from ....core.management.progressbar import show_progress
from ....users.models import Ban
from ...bans import get_fake_username_ban, get_fake_email_ban, get_fake_ip_ban
class Command(BaseCommand):
help = "Creates random fakey bans for testing purposes"
def handle(self, *args, **options):
try:
fake_bans_to_create = int(args[0])
except IndexError:
fake_bans_to_create = 5
except ValueError:
self.stderr.write("\nOptional argument should be integer.")
sys.exit(1)
fake = Factory.create()
ban_fakers = (get_fake_username_ban, get_fake_email_ban, get_fake_ip_ban)
message = "Creating %s fake bans...\n"
self.stdout.write(message % fake_bans_to_create)
created_count = 0
show_progress(self, created_count, fake_bans_to_create)
for _ in range(fake_bans_to_create):
ban_faker = random.choice(ban_fakers)
ban_faker(fake)
created_count += 1
show_progress(self, created_count, fake_bans_to_create)
Ban.objects.invalidate_cache()
message = "\n\nSuccessfully created %s fake bans"
self.stdout.write(message % created_count)
| 1,336
|
Python
|
.py
| 31
| 35.032258
| 81
| 0.657651
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,838
|
createfakeposts.py
|
rafalp_Misago/misago/faker/management/commands/createfakeposts.py
|
import random
import time
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from faker import Factory
from ....categories.models import Category
from ....core.management.progressbar import show_progress
from ....threads.models import Thread
from ...posts import get_fake_hidden_post, get_fake_post, get_fake_unapproved_post
User = get_user_model()
class Command(BaseCommand):
help = "Creates random posts for dev and testing purposes."
def add_arguments(self, parser):
parser.add_argument(
"posts", help="number of posts to create", nargs="?", type=int, default=5
)
def handle(self, *args, **options):
items_to_create = options["posts"]
fake = Factory.create()
message = "Creating %s fake posts...\n"
self.stdout.write(message % items_to_create)
created_posts = 0
start_time = time.time()
show_progress(self, created_posts, items_to_create)
while created_posts < items_to_create:
thread = Thread.objects.order_by("?")[:1].first()
# 10% chance poster is anonymous
if random.randint(0, 100) > 90:
poster = None
else:
poster = User.objects.order_by("?").last()
# There's 5% chance post is unapproved
if random.randint(0, 100) > 90:
get_fake_unapproved_post(fake, thread, poster)
# There's further 5% chance post is hidden
elif random.randint(0, 100) > 95:
if random.randint(0, 100) > 90:
hidden_by = None
else:
hidden_by = User.objects.order_by("?").last()
get_fake_hidden_post(fake, thread, poster, hidden_by)
# Default, standard post
else:
get_fake_post(fake, thread, poster)
created_posts += 1
show_progress(self, created_posts, items_to_create, start_time)
for thread in Thread.objects.iterator(chunk_size=50):
thread.synchronize()
thread.save()
for category in Category.objects.iterator():
category.synchronize()
category.save()
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\nSuccessfully created %s fake posts in %s"
self.stdout.write(message % (created_posts, total_humanized))
| 2,519
|
Python
|
.py
| 56
| 34.785714
| 85
| 0.609247
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,839
|
createfakenotifications.py
|
rafalp_Misago/misago/faker/management/commands/createfakenotifications.py
|
import random
import time
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from ....core.management.progressbar import show_progress
from ....notifications.models import Notification
from ....notifications.verbs import NotificationVerb
from ....threads.models import Post
User = get_user_model()
class Command(BaseCommand):
help = "Adds notifications entries for all users and posts"
def handle(self, *args, **options):
total_users = User.objects.count()
total_posts = Post.objects.count()
self.stdout.write(
f"Creating notifications entries for {total_users} users "
f"and {total_posts} posts...\n"
)
Notification.objects.all().delete()
total_notifications = total_users * total_posts
processed_count = 0
start_time = time.time()
show_progress(self, processed_count, total_notifications)
post_fields = (
"id",
"thread_id",
"category_id",
"thread__title",
"poster_id",
"poster_name",
"posted_on",
)
for user in User.objects.iterator(chunk_size=50):
for post in Post.objects.values(*post_fields).iterator(chunk_size=50):
Notification.objects.create(
user=user,
category_id=post["category_id"],
thread_id=post["thread_id"],
thread_title=post["thread__title"],
post_id=post["id"],
actor_id=post["poster_id"],
actor_name=post["poster_name"],
verb=NotificationVerb.REPLIED,
is_read=random.choice((True, False)),
created_at=post["posted_on"],
)
processed_count += 1
show_progress(self, processed_count, total_notifications)
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\nSuccessfully created %s notifications in %s"
self.stdout.write(message % (total_notifications, total_humanized))
| 2,235
|
Python
|
.py
| 52
| 31.711538
| 82
| 0.591517
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,840
|
createfakecategories.py
|
rafalp_Misago/misago/faker/management/commands/createfakecategories.py
|
import random
import time
from django.core.management.base import BaseCommand
from faker import Factory
from ....acl.cache import clear_acl_cache
from ....categories.models import Category
from ....core.management.progressbar import show_progress
from ...categories import fake_category, fake_closed_category
class Command(BaseCommand):
help = "Creates fake categories for dev and testing purposes."
def add_arguments(self, parser):
parser.add_argument(
"categories",
help="number of categories to create",
nargs="?",
type=int,
default=5,
)
parser.add_argument(
"level",
help="level of created categories",
nargs="?",
type=int,
default=1,
)
def handle(self, *args, **options): # pylint: disable=too-many-locals
items_to_create = options["categories"]
level = options["level"]
fake = Factory.create()
categories = Category.objects.all_categories(include_root=True).filter(
level=level - 1
)
acl_source = list(Category.objects.all_categories())[0]
if not categories.exists():
self.stdout.write("No valid parent categories exist.\n")
return
message = "Creating %s fake categories...\n"
self.stdout.write(message % items_to_create)
created_count = 0
start_time = time.time()
show_progress(self, created_count, items_to_create)
while created_count < items_to_create:
parent = random.choice(categories)
if random.randint(0, 100) > 90:
fake_closed_category(fake, parent, copy_permissions=acl_source)
else:
fake_category(fake, parent, copy_permissions=acl_source)
created_count += 1
show_progress(self, created_count, items_to_create, start_time)
clear_acl_cache()
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\n\nSuccessfully created %s fake categories in %s"
self.stdout.write(message % (created_count, total_humanized))
| 2,242
|
Python
|
.py
| 54
| 32.12963
| 79
| 0.623676
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,841
|
createfakethreads.py
|
rafalp_Misago/misago/faker/management/commands/createfakethreads.py
|
import random
import time
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from faker import Factory
from ....categories.models import Category
from ....core.management.progressbar import show_progress
from ....threads.models import Thread
from ...threads import (
get_fake_closed_thread,
get_fake_hidden_thread,
get_fake_thread,
get_fake_unapproved_thread,
)
User = get_user_model()
class Command(BaseCommand):
help = "Creates random threads for dev and testing purposes."
def add_arguments(self, parser):
parser.add_argument(
"threads",
help="number of threads to create",
nargs="?",
type=int,
default=5,
)
def handle(
self, *args, **options
): # pylint: disable=too-many-locals, too-many-branches
items_to_create = options["threads"]
fake = Factory.create()
categories = list(Category.objects.all_categories())
message = "Creating %s fake threads...\n"
self.stdout.write(message % items_to_create)
created_threads = 0
start_time = time.time()
show_progress(self, created_threads, items_to_create)
while created_threads < items_to_create:
category = random.choice(categories)
# 10% chance thread poster is anonymous
if random.randint(0, 100) > 90:
starter = None
else:
starter = User.objects.order_by("?").last()
# There's 10% chance thread is closed
if random.randint(0, 100) > 90:
thread = get_fake_closed_thread(fake, category, starter)
# There's further 5% chance thread is hidden
elif random.randint(0, 100) > 95:
if random.randint(0, 100) > 90:
hidden_by = None
else:
hidden_by = User.objects.order_by("?").last()
thread = get_fake_hidden_thread(fake, category, starter, hidden_by)
# And further 5% chance thread is unapproved
elif random.randint(0, 100) > 95:
thread = get_fake_unapproved_thread(fake, category, starter)
# Default, standard thread
else:
thread = get_fake_thread(fake, category, starter)
thread.synchronize()
thread.save()
created_threads += 1
show_progress(self, created_threads, items_to_create, start_time)
pinned_threads = random.randint(0, int(created_threads * 0.025)) or 1
self.stdout.write("\nPinning %s threads..." % pinned_threads)
for _ in range(0, pinned_threads):
thread = Thread.objects.order_by("?")[:1][0]
if random.randint(0, 100) > 90:
thread.weight = 2
else:
thread.weight = 1
thread.save()
for category in categories:
category.synchronize()
category.save()
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\nSuccessfully created %s fake threads in %s"
self.stdout.write(message % (created_threads, total_humanized))
| 3,320
|
Python
|
.py
| 79
| 31.670886
| 83
| 0.596333
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,842
|
createfakewatchedthreads.py
|
rafalp_Misago/misago/faker/management/commands/createfakewatchedthreads.py
|
import random
import time
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from ....core.management.progressbar import show_progress
from ....notifications.models import WatchedThread
from ....threads.models import Thread
User = get_user_model()
class Command(BaseCommand):
help = "Adds watched threads entries for all users and threads"
def handle(self, *args, **options):
total_users = User.objects.count()
total_threads = Thread.objects.count()
self.stdout.write(
f"Creating watched thread entries for {total_users} users "
f"and {total_threads} threads...\n"
)
WatchedThread.objects.all().delete()
total_watched_threads = total_users * total_threads
processed_count = 0
start_time = time.time()
show_progress(self, processed_count, total_watched_threads)
for user in User.objects.iterator(chunk_size=50):
for thread in Thread.objects.iterator(chunk_size=50):
WatchedThread.objects.create(
user=user,
category_id=thread.category_id,
thread=thread,
send_emails=random.choice((True, False)),
read_time=thread.last_post_on,
)
processed_count += 1
show_progress(self, processed_count, total_watched_threads)
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\nSuccessfully created %s watched threads in %s"
self.stdout.write(message % (total_watched_threads, total_humanized))
| 1,727
|
Python
|
.py
| 37
| 36.675676
| 77
| 0.642218
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,843
|
createfakehistory.py
|
rafalp_Misago/misago/faker/management/commands/createfakehistory.py
|
import random
import time
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from django.db.models import F
from django.utils import timezone
from faker import Factory
from ....categories.models import Category
from ....notifications.models import Notification, WatchedThread
from ....notifications.verbs import NotificationVerb
from ....threads.checksums import update_post_checksum
from ....threads.models import Thread
from ....users.models import Rank
from ...posts import get_fake_hidden_post, get_fake_post, get_fake_unapproved_post
from ...threads import (
get_fake_closed_thread,
get_fake_hidden_thread,
get_fake_thread,
get_fake_unapproved_thread,
)
from ...users import (
get_fake_admin_activated_user,
get_fake_banned_user,
get_fake_deleted_user,
get_fake_inactive_user,
get_fake_user,
)
User = get_user_model()
class Command(BaseCommand):
help = "Creates fake forum history reaching specified period."
def add_arguments(self, parser):
parser.add_argument(
"length",
help="generated history length (in days)",
nargs="?",
type=int,
default=5,
)
parser.add_argument(
"max_actions",
help="number of items generate for a single day",
nargs="?",
type=int,
default=50,
)
def handle(self, *args, **options): # pylint: disable=too-many-locals
history_length = options["length"]
max_actions = options["max_actions"]
fake = Factory.create()
categories = list(Category.objects.all_categories())
ranks = list(Rank.objects.all())
message = "Creating fake forum history for %s days...\n"
self.stdout.write(message % history_length)
start_time = time.time()
self.move_existing_users_to_past(history_length)
start_timestamp = timezone.now()
for days_ago in reversed(range(history_length)):
date = start_timestamp - timedelta(days=days_ago)
for date_variation in get_random_date_variations(date, 0, max_actions):
action = random.randint(0, 100)
if action >= 80:
self.create_fake_user(fake, date_variation, ranks)
elif action > 50:
self.create_fake_thread(fake, date_variation, categories)
else:
self.create_fake_post(fake, date_variation)
if random.randint(0, 100) > 80:
self.create_fake_follow(date)
self.synchronize_threads()
self.synchronize_categories()
self.synchronize_watched_threads()
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "\n\nSuccessfully created fake history for %s days in %s"
self.stdout.write(message % (history_length, total_humanized))
def move_existing_users_to_past(self, history_length):
for user in User.objects.all():
user.joined_on -= timedelta(days=history_length)
user.save(update_fields=["joined_on"])
user.audittrail_set.all().delete()
def create_fake_user(self, fake, date, ranks):
# Pick random rank for next user
rank = random.choice(ranks)
# There's 10% chance user is inactive
if random.randint(0, 100) > 90:
user = get_fake_inactive_user(fake, rank)
# There's another 10% chance user is admin-activated
elif random.randint(0, 100) > 90:
user = get_fake_admin_activated_user(fake, rank)
# And further chance user is banned
elif random.randint(0, 100) > 90:
user = get_fake_banned_user(fake, rank)
# Or deleted their account
elif random.randint(0, 100) > 90:
user = get_fake_deleted_user(fake, rank)
# User is active
else:
user = get_fake_user(fake, rank)
user.joined_on = date
user.save(update_fields=["joined_on"])
user.audittrail_set.all().delete()
self.write_event(date, "%s has joined" % user)
def create_fake_thread(self, fake, date, categories):
category = random.choice(categories)
# 10% chance thread poster is anonymous
if random.randint(0, 100) > 90:
starter = None
else:
starter = self.get_random_user(date)
# There's 10% chance thread is closed
if random.randint(0, 100) > 90:
thread = get_fake_closed_thread(fake, category, starter)
# There's further 5% chance thread is hidden
elif random.randint(0, 100) > 95:
if random.randint(0, 100) > 90:
hidden_by = None
else:
hidden_by = self.get_random_user(date)
thread = get_fake_hidden_thread(fake, category, starter, hidden_by)
# And further 5% chance thread is unapproved
elif random.randint(0, 100) > 95:
thread = get_fake_unapproved_thread(fake, category, starter)
# Default, standard thread
else:
thread = get_fake_thread(fake, category, starter)
thread.first_post.posted_on = date
thread.first_post.updated_on = date
thread.first_post.checksum = update_post_checksum(thread.first_post)
thread.first_post.save(update_fields=["checksum", "posted_on", "updated_on"])
if starter and random.randint(0, 100) > 15:
WatchedThread.objects.create(
user=starter,
category=thread.category,
thread=thread,
send_emails=random.choice((True, False)),
)
thread.started_on = date
thread.save(update_fields=["started_on"])
self.write_event(
date, '%s has started "%s" thread' % (thread.first_post.poster_name, thread)
)
def create_fake_post(self, fake, date):
thread = self.get_random_thread(date)
if not thread:
return
# 10% chance poster is anonymous
if random.randint(0, 100) > 90:
poster = None
else:
poster = self.get_random_user(date)
# There's 5% chance post is unapproved
if random.randint(0, 100) > 90:
post = get_fake_unapproved_post(fake, thread, poster)
# There's further 5% chance post is hidden
elif random.randint(0, 100) > 95:
if random.randint(0, 100) > 90:
hidden_by = None
else:
hidden_by = self.get_random_user(date)
post = get_fake_hidden_post(fake, thread, poster, hidden_by)
# Default, standard post
else:
post = get_fake_post(fake, thread, poster)
if poster:
if (
random.randint(0, 100) > 50
and not WatchedThread.objects.filter(
user=poster, thread=thread
).exists()
):
WatchedThread.objects.create(
user=poster,
category=thread.category,
thread=thread,
send_emails=random.choice((True, False)),
)
self.create_fake_notification(thread, post, poster)
post.posted_on = date
post.updated_on = date
post.checksum = update_post_checksum(post)
post.save(update_fields=["checksum", "posted_on", "updated_on"])
self.write_event(
date, '%s has replied to "%s" thread' % (post.poster_name, thread)
)
def create_fake_notification(self, thread, post, poster):
users_ids = list(
thread.watchedthread_set.exclude(user=poster)
.values_list("user_id", flat=True)
.distinct()
)
if None in users_ids:
users_ids.remove(None)
if users_ids:
Notification.objects.bulk_create(
[
Notification(
user_id=user_id,
verb=NotificationVerb.REPLIED,
actor=poster,
actor_name=poster.username,
category=post.category,
thread=thread,
thread_title=thread.title,
post=post,
is_read=random.randint(0, 100) > 25,
)
for user_id in users_ids
]
)
User.objects.filter(id__in=users_ids).update(
unread_notifications=F("unread_notifications") + 1,
)
def create_fake_follow(self, date):
user_a = self.get_random_user(date)
user_b = self.get_random_user(date)
if not (user_a or user_b) or user_a == user_b:
return
if not user_a.is_following(user_b):
user_a.follows.add(user_b)
self.write_event(date, "%s followed %s" % (user_a, user_b))
def get_random_thread(self, date):
return (
Thread.objects.filter(started_on__lt=date)
.select_related("category")
.order_by("?")
.first()
)
def get_random_user(self, date):
return (
User.objects.filter(
joined_on__lt=date, requires_activation=User.ACTIVATION_NONE
)
.order_by("?")
.first()
)
def write_event(self, date, event):
formatted_date = date.strftime("%Y-%m-%d %H:%M")
self.stdout.write("%s: %s" % (formatted_date, event))
def synchronize_threads(self):
self.stdout.write("\nSynchronizing threads...")
start_time = time.time()
for thread in Thread.objects.iterator(chunk_size=50):
thread.synchronize()
thread.save()
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "Synchronized %s threads in %s"
self.stdout.write(message % (Thread.objects.count(), total_humanized))
def synchronize_categories(self):
self.stdout.write("\nSynchronizing categories...")
start_time = time.time()
for category in Category.objects.all_categories():
category.synchronize()
category.save()
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "Synchronized %s categories in %s"
self.stdout.write(message % (Category.objects.count(), total_humanized))
def synchronize_watched_threads(self):
self.stdout.write("\nSynchronizing watched threads...")
start_time = time.time()
queryset = WatchedThread.objects.select_related("thread")
for watched_thread in queryset.iterator(chunk_size=50):
watched_thread.read_time = watched_thread.thread.last_post_on
watched_thread.save(update_fields=["read_time"])
total_time = time.time() - start_time
total_humanized = time.strftime("%H:%M:%S", time.gmtime(total_time))
message = "Synchronized %s watched threads in %s"
self.stdout.write(message % (WatchedThread.objects.count(), total_humanized))
def get_random_date_variations(date, min_date, max_date):
variations = []
for _ in range(random.randint(min_date, max_date)):
random_offset = timedelta(minutes=random.randint(1, 1200))
variations.append(date - random_offset)
return sorted(variations)
| 11,770
|
Python
|
.py
| 276
| 31.771739
| 88
| 0.590372
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,844
|
urls.py
|
rafalp_Misago/misago/account/urls.py
|
from django.urls import path
from .views import settings, validate
urlpatterns = [
path("", settings.index, name="account-settings"),
path(
"preferences/",
settings.AccountPreferencesView.as_view(),
name="account-preferences",
),
path(
"details/",
settings.AccountDetailsView.as_view(),
name="account-details",
),
path(
"username/",
settings.AccountUsernameView.as_view(),
name="account-username",
),
path(
"password/",
settings.AccountPasswordView.as_view(),
name="account-password",
),
path(
"email/",
settings.AccountEmailView.as_view(),
name="account-email",
),
path(
"email/confirm/",
settings.AccountEmailConfirm.as_view(),
name="account-email-confirm-sent",
),
path(
"email/confirm/<int:user_id>/<token>/",
settings.account_email_confirm_change,
name="account-email-confirm-change",
),
path(
"download-data/",
settings.AccountDownloadDataView.as_view(),
name="account-download-data",
),
path(
"delete/",
settings.AccountDeleteView.as_view(),
name="account-delete",
),
path(
"delete/completed/",
settings.account_delete_completed,
name="account-delete-completed",
),
path(
"validate/email/",
validate.email,
name="account-validate-email",
),
path(
"validate/username/",
validate.username,
name="account-validate-username",
),
path(
"validate/password/",
validate.password,
name="account-validate-password",
),
]
| 1,741
|
Python
|
.py
| 70
| 17.828571
| 54
| 0.585132
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,845
|
apps.py
|
rafalp_Misago/misago/account/apps.py
|
from django.apps import AppConfig
class MisagoAccountConfig(AppConfig):
name = "misago.account"
label = "misago_account"
verbose_name = "Misago Account"
| 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,846
|
namechanges.py
|
rafalp_Misago/misago/account/namechanges.py
|
from dataclasses import dataclass
from datetime import datetime, timedelta
from django.utils import timezone
@dataclass
class AvailableUsernameChanges:
unlimited: bool
changes_left: int | None
next_change: datetime | None
@property
def can_change_username(self) -> bool:
if self.unlimited or self.changes_left > 0:
return bool(self.next_change is None or self.next_change < timezone.now())
return False
def get_available_username_changes(user, permissions) -> AvailableUsernameChanges:
if not permissions.can_change_username:
return AvailableUsernameChanges(
unlimited=False,
changes_left=0,
next_change=None,
)
changes_left = get_username_changes_left(user, permissions)
next_change = get_username_next_change(user, permissions, changes_left)
return AvailableUsernameChanges(
unlimited=permissions.username_changes_limit == 0,
changes_left=changes_left,
next_change=next_change,
)
def get_username_changes_left(user, permissions) -> int | None:
if permissions.username_changes_limit == 0:
return None
queryset = user.namechanges.filter(changed_by=user)
if permissions.username_changes_expire:
expired_cutoff = timezone.now() - timedelta(
hours=permissions.username_changes_expire,
)
queryset = queryset.filter(changed_on__gt=expired_cutoff)
return max((permissions.username_changes_limit - queryset.count(), 0))
def get_username_next_change(user, permissions, changes_left: int) -> datetime | None:
if changes_left == 0:
return get_username_next_change_if_out_of_changes(user, permissions)
# User has either unlimited changes or some changes left
if permissions.username_changes_span:
return get_newest_change(user, permissions)
return None
def get_username_next_change_if_out_of_changes(user, permissions) -> datetime | None:
# Changes don't expire, no more changes will be possible for the user
if not permissions.username_changes_expire:
return None
oldest_change = get_oldest_expiring_change(user, permissions)
if oldest_change is None:
return None
# We'll be able to change username when oldest change expires
if not permissions.username_changes_span:
return oldest_change
newest_change = get_newest_change(user, permissions)
if newest_change is None:
return None
return max((oldest_change, newest_change))
def get_oldest_expiring_change(user, permissions) -> datetime | None:
expired_cutoff = timezone.now() - timedelta(
hours=permissions.username_changes_expire,
)
change = user.namechanges.filter(
changed_by=user,
changed_on__gt=expired_cutoff,
).first()
if not change:
return None
return change.changed_on + timedelta(
hours=permissions.username_changes_expire,
)
def get_newest_change(user, permissions) -> datetime | None:
change = user.namechanges.filter(changed_by=user).last()
if not change:
return None
return change.changed_on + timedelta(
hours=permissions.username_changes_span,
)
| 3,238
|
Python
|
.py
| 78
| 34.910256
| 86
| 0.708666
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,847
|
menus.py
|
rafalp_Misago/misago/account/menus.py
|
from django.conf import settings
from django.http import HttpRequest
from django.utils.translation import pgettext_lazy
from ..menus.menu import Menu
account_settings_menu = Menu()
account_settings_menu.add_item(
key="preferences",
url_name="misago:account-preferences",
label=pgettext_lazy("account settings page", "Preferences"),
icon="tune",
)
def show_profile_details(request: HttpRequest) -> bool:
return bool(settings.MISAGO_PROFILE_FIELDS)
account_settings_menu.add_item(
key="details",
url_name="misago:account-details",
label=pgettext_lazy("account settings page", "Profile details"),
icon="person_outline",
visible=show_profile_details,
)
def auth_is_not_delegated(request: HttpRequest) -> bool:
return not request.settings.enable_oauth2_client
account_settings_menu.add_item(
key="username",
url_name="misago:account-username",
label=pgettext_lazy("account settings page", "Username"),
icon="card_membership",
visible=auth_is_not_delegated,
)
account_settings_menu.add_item(
key="password",
url_name="misago:account-password",
label=pgettext_lazy("account settings page", "Password"),
icon="vpn_key",
visible=auth_is_not_delegated,
)
account_settings_menu.add_item(
key="password",
url_name="misago:account-email",
label=pgettext_lazy("account settings page", "Email address"),
icon="mail_outline",
visible=auth_is_not_delegated,
)
def show_download_data(request: HttpRequest) -> bool:
return request.settings.allow_data_downloads
account_settings_menu.add_item(
key="download-data",
url_name="misago:account-download-data",
label=pgettext_lazy("account settings page", "Download data"),
icon="save_alt",
visible=show_download_data,
)
def show_delete_own_account(request: HttpRequest) -> bool:
if not auth_is_not_delegated(request):
return False
return request.settings.allow_delete_own_account
account_settings_menu.add_item(
key="delete",
url_name="misago:account-delete",
label=pgettext_lazy("account settings page", "Delete account"),
icon="cancel",
visible=show_delete_own_account,
)
| 2,189
|
Python
|
.py
| 63
| 30.746032
| 68
| 0.73822
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,848
|
forms.py
|
rafalp_Misago/misago/account/forms.py
|
from dataclasses import dataclass
from functools import cached_property
from typing import Any
from django import forms
from django.core.exceptions import PermissionDenied
from django.contrib.auth import get_user_model, update_session_auth_hash
from django.contrib.auth.password_validation import validate_password
from django.utils.translation import pgettext, pgettext_lazy
from ..permissions.accounts import check_delete_own_account_permission
from ..profile.profilefields import profile_fields
from ..users.utils import hash_email
from ..users.validators import validate_email, validate_username
from .namechanges import get_available_username_changes
User = get_user_model()
class AccountPreferencesForm(forms.ModelForm):
class Meta:
model = User
fields = [
"limits_private_thread_invites_to",
"watch_started_threads",
"watch_replied_threads",
"watch_new_private_threads_by_followed",
"watch_new_private_threads_by_other_users",
"notify_new_private_threads_by_followed",
"notify_new_private_threads_by_other_users",
]
widgets = {
"limits_private_thread_invites_to": forms.RadioSelect(),
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
user = kwargs["instance"]
self.fields["is_hiding_presence"] = forms.TypedChoiceField(
coerce=int,
choices=(
(
0,
pgettext_lazy(
"account privacy choice",
"Show other users when I am online",
),
),
(
1,
pgettext_lazy(
"account privacy choice",
"Don't show other users when I am online",
),
),
),
initial=1 if user.is_hiding_presence else 0,
widget=forms.RadioSelect(),
)
def save(self):
self.instance.is_hiding_presence = self.cleaned_data.get("is_hiding_presence")
return super().save()
class AccountNotifications:
header: str
items: dict[str, str]
def __init__(self, header: str):
self.header = header
self.items = {}
def add_item(self, field: str, label: str):
self.items[field] = label
def get_items(self, form: forms.Form) -> "AccountNotificationsItems":
items: list["AccountNotificationsItem"] = []
for field_name, label in self.items.items():
items.append(
AccountNotificationsItem(
label=label,
field=form[field_name],
)
)
return AccountNotificationsItems(
header=self.header,
items=items,
)
@dataclass
class AccountNotificationsItems:
header: str
items: list["AccountNotificationsItem"]
@dataclass
class AccountNotificationsItem:
label: str
field: forms.BoundField
watching_preferences = AccountNotifications(
pgettext_lazy("account settings preferences watching", "Content")
)
watching_preferences.add_item(
"watch_started_threads",
pgettext_lazy(
"account settings preferences",
"Threads I am starting",
),
)
watching_preferences.add_item(
"watch_replied_threads",
pgettext_lazy(
"account settings preferences",
"Threads I am replying to",
),
)
watching_preferences.add_item(
"watch_new_private_threads_by_followed",
pgettext_lazy(
"account settings preferences",
"Private threads I am invited to by users I follow",
),
)
watching_preferences.add_item(
"watch_new_private_threads_by_other_users",
pgettext_lazy(
"account settings preferences",
"Private threads I am invited to by other users",
),
)
notifications_preferences = AccountNotifications(
pgettext_lazy("account settings preferences watching", "Event")
)
notifications_preferences.add_item(
"notify_new_private_threads_by_followed",
pgettext_lazy(
"account settings preferences",
"Private threads invitations from users I follow",
),
)
notifications_preferences.add_item(
"notify_new_private_threads_by_other_users",
pgettext_lazy(
"account settings preferences",
"Private threads invitations from other users",
),
)
class AccountDetailsForm(forms.Form):
def __init__(self, *args, **kwargs):
self.request = kwargs.pop("request")
self.instance = kwargs.pop("instance")
super().__init__(*args, **kwargs)
self.form_data = profile_fields.get_form_data(self.request, self.instance)
self.fields.update(self.form_data.fields)
@property
def fieldsets(self):
for fieldset in self.form_data.fieldsets:
yield {
"name": fieldset["name"],
"fields": (self[field] for field in fieldset["fields"]),
}
def clean(self):
cleaned_data: dict[str, Any] = {}
for field, data in dict(super().clean()).items():
if field not in self.form_data.fields:
continue
try:
cleaned_data[field] = self.form_data.clean_data(
field, data, self.request, self.instance
)
except forms.ValidationError as e:
self.add_error(field, e)
return cleaned_data
def save(self):
new_data: dict[str, Any] = {}
for field_name in self.form_data.fields:
if self.cleaned_data.get(field_name):
new_data[field_name] = self.cleaned_data[field_name]
self.instance.profile_fields = new_data
self.instance.save(update_fields=["profile_fields"])
class AccountUsernameForm(forms.Form):
username = forms.CharField(max_length=255)
def __init__(self, *args, **kwargs):
request = kwargs.pop("request")
self.instance = kwargs.pop("instance")
self.permissions = request.user_permissions
self.settings = request.settings
self.username_cache = None
super().__init__(*args, **kwargs)
self.fields["username"].max_length = self.settings.username_length_max
@cached_property
def available_changes(self):
return get_available_username_changes(self.instance, self.permissions)
def clean_username(self):
data = self.cleaned_data["username"]
if data == self.instance.username:
raise forms.ValidationError(
pgettext(
"account username form",
"This username is the same as the current one.",
),
)
if not self.permissions.can_change_username:
raise forms.ValidationError(
pgettext(
"account username help",
"You can't change your username.",
),
)
if not self.available_changes.can_change_username:
raise forms.ValidationError(
pgettext(
"account username help",
"You can't change your username at the moment.",
),
)
validate_username(self.settings, data, self.instance)
return data
def clean(self):
super().clean()
if "username" not in self.errors:
self["username"].value = ""
def save(self):
username = self.cleaned_data["username"]
if username != self.instance.username:
self.instance.set_username(username, changed_by=self.instance)
self.instance.save()
del self.available_changes
return self.instance
class AccountPasswordForm(forms.Form):
current_password = forms.CharField(max_length=255, widget=forms.PasswordInput)
new_password = forms.CharField(max_length=255, widget=forms.PasswordInput)
confirm_password = forms.CharField(max_length=255, widget=forms.PasswordInput)
def __init__(self, *args, **kwargs):
self.request = kwargs.pop("request")
self.instance = kwargs.pop("instance")
super().__init__(*args, **kwargs)
def clean_current_password(self):
data = self.cleaned_data["current_password"]
if not self.instance.check_password(data):
raise forms.ValidationError(
pgettext(
"account settings form",
"Password is incorrect.",
),
)
return data
def clean_new_password(self):
data = self.cleaned_data["new_password"]
validate_password(data)
return data
def clean(self):
cleaned_data = super().clean()
if cleaned_data.get("new_password") and cleaned_data.get(
"confirm_password"
) != cleaned_data.get("new_password"):
self.add_error(
"confirm_password",
pgettext(
"account password form",
"New passwords don't match.",
),
)
return cleaned_data
def save(self):
self.instance.set_password(self.cleaned_data["new_password"])
self.instance.save()
update_session_auth_hash(self.request, self.instance)
return self.instance
class AccountEmailForm(forms.Form):
current_password = forms.CharField(max_length=255, widget=forms.PasswordInput)
new_email = forms.EmailField(max_length=255, widget=forms.PasswordInput)
confirm_email = forms.EmailField(max_length=255, widget=forms.PasswordInput)
def __init__(self, *args, **kwargs):
self.request = kwargs.pop("request")
self.instance = kwargs.pop("instance")
self.email_cache = None
super().__init__(*args, **kwargs)
def clean_current_password(self):
data = self.cleaned_data["current_password"]
if not self.instance.check_password(data):
raise forms.ValidationError(
pgettext(
"account settings form",
"Password is incorrect.",
),
)
return data
def clean_new_email(self):
data = self.cleaned_data["new_email"]
if hash_email(data) == self.instance.email_hash:
raise forms.ValidationError(
pgettext(
"account email form",
"This email address is the same as the current one.",
),
)
validate_email(data, self.instance)
return data
def clean(self):
cleaned_data = super().clean()
if cleaned_data.get("new_email") and cleaned_data.get(
"confirm_email"
) != cleaned_data.get("new_email"):
self.add_error(
"confirm_email",
pgettext(
"account email form",
"New email addresses don't match.",
),
)
return cleaned_data
class AccountDeleteForm(forms.Form):
password = forms.CharField(
max_length=255,
widget=forms.PasswordInput,
required=True,
strip=False,
)
def __init__(self, *args, **kwargs):
self.instance = kwargs.pop("instance")
super().__init__(*args, **kwargs)
def clean_password(self):
data = self.cleaned_data["password"]
if not self.instance.check_password(data):
raise forms.ValidationError(
pgettext(
"account delete form",
"Entered password is incorrect.",
),
)
try:
check_delete_own_account_permission(self.instance)
except PermissionDenied as e:
raise forms.ValidationError(str(e))
return data
| 12,014
|
Python
|
.py
| 322
| 27.23913
| 86
| 0.59647
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,849
|
emailchange.py
|
rafalp_Misago/misago/account/emailchange.py
|
import datetime
import hashlib
import hmac
from base64 import urlsafe_b64decode, urlsafe_b64encode
from datetime import timedelta
from enum import StrEnum
from typing import TYPE_CHECKING
from django.conf import settings
from django.utils import timezone
from django.utils.translation import pgettext
if TYPE_CHECKING:
from ..users.models import User
TIMESTAMP_FORMAT = "%Y%m%d%H%S"
class EmailChangeTokenErrorCode(StrEnum):
PAYLOAD_MISSING = "PAYLOAD-MISSING"
SIGNATURE_INVALID = "SIGNATURE-INVALID"
SIGNATURE_MISSING = "SIGNATURE-MISSING"
TOKEN_EXPIRED = "TOKEN-EXPIRED"
TOKEN_INVALID = "TOKEN-INVALID"
class EmailChangeTokenError(ValueError):
code: EmailChangeTokenErrorCode
def __init__(self, code: EmailChangeTokenErrorCode):
self.code = code
def __str__(self):
if self.code == EmailChangeTokenErrorCode.PAYLOAD_MISSING:
return pgettext(
"email change token error",
"Mail change confirmation link is missing a payload.",
)
if self.code == EmailChangeTokenErrorCode.TOKEN_EXPIRED:
return pgettext(
"email change token error",
"Mail change confirmation link has expired.",
)
if self.code == EmailChangeTokenErrorCode.TOKEN_INVALID:
return pgettext(
"email change token error",
"Mail change confirmation link is invalid.",
)
if self.code == EmailChangeTokenErrorCode.SIGNATURE_INVALID:
return pgettext(
"email change token error",
"Mail change confirmation link has invalid signature.",
)
if self.code == EmailChangeTokenErrorCode.SIGNATURE_MISSING:
return pgettext(
"email change token error",
"Mail change confirmation link is missing a signature.",
)
return self.code.value
def create_email_change_token(user: "User", new_email: str) -> str:
timestamp = timezone.now().strftime(TIMESTAMP_FORMAT)
payload = urlsafe_b64encode(f"{timestamp}:{new_email}".encode("utf-8"))
signature = get_email_change_signature(user, payload)
return f"{signature}-{payload.decode('utf-8')}"
def read_email_change_token(user: "User", token: str) -> str:
if "-" not in token:
raise EmailChangeTokenError(EmailChangeTokenErrorCode.TOKEN_INVALID)
signature, payload = token.split("-", 1)
if not signature:
raise EmailChangeTokenError(EmailChangeTokenErrorCode.SIGNATURE_MISSING)
if not payload:
raise EmailChangeTokenError(EmailChangeTokenErrorCode.PAYLOAD_MISSING)
if signature != get_email_change_signature(user, payload.encode("utf-8")):
raise EmailChangeTokenError(EmailChangeTokenErrorCode.SIGNATURE_INVALID)
timestamp, email = urlsafe_b64decode(payload).decode("utf-8").split(":", 1)
created = datetime.datetime.strptime(timestamp, TIMESTAMP_FORMAT).replace(
tzinfo=datetime.timezone.utc
)
expires = created + timedelta(hours=settings.MISAGO_EMAIL_CHANGE_TOKEN_EXPIRES)
if timezone.now() > expires:
raise EmailChangeTokenError(EmailChangeTokenErrorCode.TOKEN_EXPIRED)
return email
def get_email_change_secret(user: "User") -> bytes:
return (
f"{user.pk}:{user.email_hash}:{user.password}:{settings.SECRET_KEY}"
).encode("utf-8")
def get_email_change_signature(user: "User", payload: bytes) -> str:
return hmac.new(get_email_change_secret(user), payload, hashlib.sha256).hexdigest()
| 3,593
|
Python
|
.py
| 79
| 37.835443
| 87
| 0.693608
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,850
|
settings.py
|
rafalp_Misago/misago/account/views/settings.py
|
from typing import Any
from django.conf import settings
from django.contrib import messages
from django.contrib.auth import get_user_model, logout
from django.forms import Form, ValidationError
from django.http import Http404, HttpRequest, HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
from django.utils.decorators import method_decorator
from django.utils.translation import gettext as _, pgettext, pgettext_lazy
from django.views import View
from django.views.decorators.debug import sensitive_post_parameters
from ...auth.decorators import login_required
from ...core.mail import build_mail
from ...pagination.cursor import EmptyPageError, paginate_queryset
from ...pagination.redirect import redirect_to_last_page
from ...users.datadownloads import (
request_user_data_download,
user_has_data_download_request,
)
from ...users.models import DataDownload
from ...users.online.tracker import clear_tracking
from ...users.tasks import delete_user
from ...users.validators import validate_email
from ..forms import (
AccountDeleteForm,
AccountDetailsForm,
AccountEmailForm,
AccountPasswordForm,
AccountPreferencesForm,
AccountUsernameForm,
notifications_preferences,
watching_preferences,
)
from ..emailchange import (
EmailChangeTokenError,
create_email_change_token,
read_email_change_token,
)
from ..menus import account_settings_menu
User = get_user_model()
def account_settings_login_required():
return login_required(
pgettext(
"account settings login page",
"Sign in to change your settings",
)
)
@account_settings_login_required()
def index(request):
menu = account_settings_menu.bind_to_request(request)
return redirect(menu.items[0].url)
class AccountSettingsView(View):
@method_decorator(account_settings_login_required())
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
try:
return super().dispatch(request, *args, **kwargs)
except EmptyPageError as exception:
return redirect_to_last_page(request, exception)
def get_context_data(
self,
request: HttpRequest,
context: dict[str, Any],
) -> dict[str, Any]:
return context
def render(
self,
request: HttpRequest,
template_name: str,
context: dict[str, Any] | None = None,
) -> HttpResponse:
final_context = self.get_context_data(request, context or {})
final_context["account_menu"] = account_settings_menu.bind_to_request(request)
return render(request, template_name, final_context)
class AccountSettingsFormView(AccountSettingsView):
template_name: str
template_name_htmx: str | None = None
success_message: str
def get_form_instance(self, request: HttpRequest) -> Form:
raise NotImplementedError()
def save_form(self, request: HttpRequest, form: Form) -> None:
form.save()
def get_context_data(
self,
request: HttpRequest,
context: dict[str, Any],
) -> dict[str, Any]:
return context
def get(self, request: HttpRequest) -> HttpResponse:
form = self.get_form_instance(request)
return self.render(request, self.template_name, {"form": form})
def post(self, request: HttpRequest) -> HttpResponse:
form = self.get_form_instance(request)
if form.is_valid():
return self.handle_valid_form(request, form)
return self.handle_invalid_form(request, form)
def handle_valid_form(self, request: HttpRequest, form: Form) -> HttpResponse:
self.save_form(request, form)
messages.success(request, self.success_message)
if request.is_htmx and self.template_name_htmx:
return self.render(request, self.template_name_htmx, {"form": form})
return redirect(request.path_info)
def handle_invalid_form(self, request: HttpRequest, form: Form) -> HttpResponse:
messages.error(request, _("Form contains errors"))
if request.is_htmx and self.template_name_htmx:
template_name = self.template_name_htmx
else:
template_name = self.template_name
return self.render(request, template_name, {"form": form})
class AccountPreferencesView(AccountSettingsFormView):
template_name = "misago/account/settings/preferences.html"
template_name_htmx = "misago/account/settings/preferences_form.html"
success_message = pgettext_lazy(
"account settings preferences updated", "Preferences updated"
)
def get_form_instance(self, request: HttpRequest) -> AccountPreferencesForm:
if request.method == "POST":
return AccountPreferencesForm(request.POST, instance=request.user)
return AccountPreferencesForm(instance=request.user)
def get_context_data(
self,
request: HttpRequest,
context: dict[str, Any],
) -> dict[str, Any]:
form = context["form"]
context.update(
{
"notifications_preferences": notifications_preferences.get_items(form),
"watching_preferences": watching_preferences.get_items(form),
}
)
return context
class AccountDetailsView(AccountSettingsFormView):
template_name = "misago/account/settings/details.html"
template_name_htmx = "misago/account/settings/details_form.html"
success_message = pgettext_lazy(
"account settings preferences updated", "Profile updated"
)
def get_form_instance(self, request: HttpRequest) -> AccountPreferencesForm:
if request.method == "POST":
return AccountDetailsForm(
request.POST,
instance=request.user,
request=request,
)
return AccountDetailsForm(
instance=request.user,
request=request,
)
class AccountUsernameView(AccountSettingsFormView):
template_name = "misago/account/settings/username.html"
template_name_htmx = "misago/account/settings/username_form.html"
template_history_name = "misago/account/settings/username_history.html"
success_message = pgettext_lazy(
"account settings username changed", "Username changed"
)
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
if request.settings.enable_oauth2_client:
raise Http404()
return super().dispatch(request, *args, **kwargs)
def get(self, request: HttpRequest) -> HttpResponse:
form = self.get_form_instance(request)
if request.is_htmx:
template_name = self.template_history_name
else:
template_name = self.template_name
return self.render(request, template_name, {"form": form})
def get_context_data(
self,
request: HttpRequest,
context: dict[str, Any],
) -> dict[str, Any]:
context["username_history"] = self.get_username_history(request)
return context
def get_form_instance(self, request: HttpRequest) -> AccountUsernameForm:
if request.method == "POST":
return AccountUsernameForm(
request.POST,
instance=request.user,
request=request,
)
return AccountUsernameForm(
instance=request.user,
request=request,
)
def get_username_history(self, request: HttpRequest):
return paginate_queryset(
request, request.user.namechanges.select_related("changed_by"), 10, "-id"
)
class AccountPasswordView(AccountSettingsFormView):
template_name = "misago/account/settings/password.html"
template_name_htmx = "misago/account/settings/password_form.html"
email_template_name = "misago/emails/password_changed"
success_message = pgettext_lazy(
"account settings password changed", "Password changed"
)
@method_decorator(sensitive_post_parameters())
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
if request.settings.enable_oauth2_client:
raise Http404()
return super().dispatch(request, *args, **kwargs)
def get_form_instance(self, request: HttpRequest) -> AccountPasswordForm:
if request.method == "POST":
return AccountPasswordForm(
request.POST,
instance=request.user,
request=request,
)
return AccountPasswordForm(
instance=request.user,
request=request,
)
def save_form(self, request: HttpRequest, form: Form) -> None:
form.save()
mail = build_mail(
request.user,
pgettext(
"password changed email subject",
"Your password on the %(forum_name)s forums has been changed",
)
% {"forum_name": request.settings.forum_name},
self.email_template_name,
context={"settings": request.settings},
)
mail.send(fail_silently=True)
class AccountEmailView(AccountSettingsFormView):
template_name = "misago/account/settings/email.html"
template_name_htmx = "misago/account/settings/email_form.html"
template_htmx_success_name = "misago/account/settings/email_form_completed.html"
email_template_name = "misago/emails/email_confirm_change"
success_message = pgettext_lazy(
"account settings email confirm", "Confirmation email sent"
)
@method_decorator(sensitive_post_parameters("current_password"))
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
if request.settings.enable_oauth2_client:
raise Http404()
return super().dispatch(request, *args, **kwargs)
def get(self, request: HttpRequest) -> HttpResponse:
form = self.get_form_instance(request)
if request.is_htmx:
template_name = self.template_name_htmx
else:
template_name = self.template_name
return self.render(request, template_name, {"form": form})
def get_form_instance(self, request: HttpRequest) -> AccountEmailForm:
if request.method == "POST":
return AccountEmailForm(
request.POST,
instance=request.user,
request=request,
)
return AccountEmailForm(
instance=request.user,
request=request,
)
def handle_valid_form(self, request: HttpRequest, form: Form) -> HttpResponse:
self.save_form(request, form)
if request.is_htmx and self.template_name_htmx:
messages.success(request, self.success_message)
return self.render(
request,
self.template_htmx_success_name,
{"new_email": form.cleaned_data["new_email"]},
)
request.session["misago_new_email"] = form.cleaned_data["new_email"]
return redirect(reverse("misago:account-email-confirm-sent"))
def save_form(self, request: HttpRequest, form: Form) -> None:
new_email = form.cleaned_data["new_email"]
token = create_email_change_token(request.user, form.cleaned_data["new_email"])
# Swap e-mail on user instance so email is sent to a new address
request.user.email = new_email
mail = build_mail(
request.user,
pgettext(
"email confirm change email subject",
"Change your email on the %(forum_name)s forums",
)
% {"forum_name": request.settings.forum_name},
self.email_template_name,
context={
"settings": request.settings,
"token": token,
"expires_in": settings.MISAGO_EMAIL_CHANGE_TOKEN_EXPIRES,
},
)
mail.send(fail_silently=True)
class AccountEmailConfirm(AccountSettingsView):
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
if request.settings.enable_oauth2_client:
raise Http404()
return super().dispatch(request, *args, **kwargs)
def get(self, request: HttpRequest) -> HttpResponse:
new_email = request.session.pop("misago_new_email", None)
if not new_email:
return redirect(reverse("misago:account-email"))
return self.render(
request,
"misago/account/settings/email_confirm.html",
{"new_email": new_email},
)
def account_email_confirm_change(request, user_id, token):
if request.settings.enable_oauth2_client:
raise Http404()
user = get_object_or_404(User.objects, id=user_id, is_active=True)
try:
new_email = read_email_change_token(user, token)
validate_email(new_email, user)
except EmailChangeTokenError as e:
return render(
request,
"misago/account/settings/email_change_error.html",
{
"message": str(e),
"error_code": str(e.code),
},
)
except ValidationError as e:
return render(
request,
"misago/account/settings/email_change_error.html",
{"message": str(e.messages[0])},
)
if new_email != user.email:
user.set_email(new_email)
user.save()
return render(
request,
"misago/account/settings/email_changed.html",
{"username": user.username, "new_email": new_email},
)
class AccountDownloadDataView(AccountSettingsView):
template_name = "misago/account/settings/download_data.html"
template_name_htmx = "misago/account/settings/download_data_form.html"
success_message = pgettext_lazy(
"account settings data download requested", "Data download requested"
)
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
if not request.settings.allow_data_downloads:
raise Http404()
return super().dispatch(request, *args, **kwargs)
def get(self, request: HttpRequest) -> HttpResponse:
if request.is_htmx:
template_name = self.template_name_htmx
else:
template_name = self.template_name
return self.render(request, template_name)
def post(self, request: HttpRequest) -> HttpResponse:
if user_has_data_download_request(request.user):
messages.warning(
request,
pgettext(
"account settings data download requested",
"You can't request a new data download before the previous one completes.",
),
)
else:
request_user_data_download(request.user, request.user)
messages.success(request, self.success_message)
if request.is_htmx:
return self.render(request, self.template_name_htmx)
return redirect("misago:account-download-data")
def get_context_data(
self,
request: HttpRequest,
context: dict[str, Any],
) -> dict[str, Any]:
context["data_downloads"] = self.get_data_downloads(request)
context["has_data_download_request"] = user_has_data_download_request(
request.user
)
if context["data_downloads"].items:
for item in context["data_downloads"].items:
if item.status < DataDownload.STATUS_READY:
context["data_downloads_refresh"] = True
break
return context
def get_data_downloads(self, request: HttpRequest):
return paginate_queryset(request, request.user.datadownload_set, 15, "-id")
class AccountDeleteView(AccountSettingsFormView):
template_name = "misago/account/settings/delete.html"
def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
if (
request.settings.enable_oauth2_client
or not request.settings.allow_delete_own_account
):
raise Http404()
return super().dispatch(request, *args, **kwargs)
def get_form_instance(self, request: HttpRequest) -> AccountDeleteForm:
if request.method == "POST":
return AccountDeleteForm(request.POST, instance=request.user)
return AccountDeleteForm(instance=request.user)
def post(self, request: HttpRequest) -> HttpResponse:
form = self.get_form_instance(request)
if form.is_valid():
logout(request)
clear_tracking(request)
form.instance.mark_for_delete()
delete_user.delay(form.instance.id)
request.session["misago_deleted_account"] = form.instance.username
return redirect("misago:account-delete-completed")
return self.render(request, self.template_name, {"form": form})
def account_delete_completed(request):
deleted_account = request.session.pop("misago_deleted_account", None)
if not deleted_account:
raise Http404()
return render(
request,
"misago/account/settings/delete_completed.html",
{"deleted_account": deleted_account},
)
| 17,452
|
Python
|
.py
| 411
| 33.547445
| 95
| 0.653178
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,851
|
validate.py
|
rafalp_Misago/misago/account/views/validate.py
|
from functools import wraps
from django.contrib.auth import get_user_model
from django.contrib.auth.password_validation import validate_password
from django.core.exceptions import BadRequest, ValidationError
from django.http import HttpRequest, JsonResponse
from django.utils.translation import pgettext
from django.views.decorators.debug import sensitive_post_parameters
from ...users.validators import validate_email, validate_username
User = get_user_model()
def validation_view(f):
@wraps(f)
def view_wrapper(request: HttpRequest, *args, **kwargs):
try:
if request.method != "POST":
raise BadRequest()
f(request, *args, **kwargs)
return JsonResponse({"errors": []})
except ValidationError as e:
return JsonResponse({"errors": e.messages}, status=400)
return view_wrapper
def clean_value(request: HttpRequest, strip: bool = True) -> str:
value = request.POST.get("value", "")
if strip:
value = value.strip()
if not value.strip():
raise ValidationError(
pgettext("account validation api", "'value' can't be empty."),
)
return value
def get_user_from_data(request: HttpRequest):
user_id = request.POST.get("user")
if not user_id:
return None
try:
user_id_int = int(user_id)
if user_id_int < 1:
raise ValueError()
except (ValueError, TypeError):
raise ValidationError(
pgettext("account validation api", "'user' must be a positive integer."),
)
try:
return User.objects.get(id=user_id_int)
except User.DoesNotExist:
raise ValidationError(
pgettext(
"account validation api", "'user' doesn't match any user account."
),
)
@validation_view
def username(request: HttpRequest) -> JsonResponse:
user = get_user_from_data(request)
value = clean_value(request)
validate_username(request.settings, value, user)
@validation_view
def email(request: HttpRequest) -> JsonResponse:
user = get_user_from_data(request)
value = clean_value(request)
validate_email(value, user)
@sensitive_post_parameters()
@validation_view
def password(request: HttpRequest) -> JsonResponse:
user = get_user_from_data(request)
value = clean_value(request, strip=False)
validate_password(value, user)
| 2,419
|
Python
|
.py
| 65
| 30.8
| 85
| 0.680805
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,852
|
test_account_username.py
|
rafalp_Misago/misago/account/tests/test_account_username.py
|
from unittest.mock import patch
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...pagination.cursor import EmptyPageError
from ...test import assert_contains, assert_has_success_message, assert_not_contains
@override_dynamic_settings(enable_oauth2_client=True)
def test_account_username_returns_error_if_oauth_client_is_enabled(db, client):
response = client.get(reverse("misago:account-username"))
assert response.status_code == 404
def test_account_username_displays_login_page_for_guests(db, client):
response = client.get(reverse("misago:account-username"))
assert_contains(response, "Sign in to change your settings")
def test_account_username_renders_form(user_client):
response = user_client.get(reverse("misago:account-username"))
assert_contains(response, "Change username")
def test_account_username_form_changes_username(user_client, user):
response = user_client.post(
reverse("misago:account-username"), {"username": "JohnDoe"}
)
assert response.status_code == 302
assert_has_success_message(response, "Username changed")
user.refresh_from_db()
assert user.username == "JohnDoe"
change = user.namechanges.first()
assert change.new_username == "JohnDoe"
assert change.old_username == "User"
def test_account_username_form_validates_username_is_new(user_client, user):
response = user_client.post(
reverse("misago:account-username"), {"username": user.username}
)
assert response.status_code == 200
assert_contains(response, "This username is the same as the current one.")
user.refresh_from_db()
assert user.username == "User"
def test_account_username_form_validates_username(user_client, admin, user):
response = user_client.post(
reverse("misago:account-username"), {"username": admin.username}
)
assert response.status_code == 200
assert_contains(response, "This username is not available.")
user.refresh_from_db()
assert user.username == "User"
def test_account_username_form_validates_username_change_permission(user_client, user):
user.group.can_change_username = False
user.group.save()
response = user_client.post(
reverse("misago:account-username"), {"username": "JohnDoe"}
)
assert response.status_code == 200
assert_contains(response, "You can't change your username.")
user.refresh_from_db()
assert user.username == "User"
def test_account_username_form_validates_username_change_cooldown(user_client, user):
user.group.username_changes_span = 1
user.group.save()
user.set_username("John", user)
response = user_client.post(
reverse("misago:account-username"), {"username": "JohnDoe"}
)
assert response.status_code == 200
assert_contains(response, "You can't change your username at the moment.")
user.refresh_from_db()
assert user.username == "User"
def test_account_username_renders_message_about_unlimited_username_changes(
user_client, user
):
user.group.username_changes_limit = 0
user.group.save()
response = user_client.get(reverse("misago:account-username"))
assert_contains(response, "Change username")
assert_contains(response, "You can change your username unlimited number of times.")
def test_account_username_renders_message_about_username_changes_disabled(
user_client, user
):
user.group.can_change_username = False
user.group.save()
response = user_client.get(reverse("misago:account-username"))
assert_contains(response, "Change username")
assert_contains(response, "You can't change your username.")
def test_account_username_renders_message_about_username_changes_left(
user_client, user
):
user.group.username_changes_limit = 2
user.group.username_changes_span = 0
user.group.save()
user.set_username("John", user)
response = user_client.get(reverse("misago:account-username"))
assert_contains(response, "Change username")
assert_contains(response, "You can change your username 1 more time.")
def test_account_username_renders_message_about_username_change_cooldown(
user_client, user
):
user.group.username_changes_span = 1
user.group.save()
user.set_username("John", user)
response = user_client.get(reverse("misago:account-username"))
assert_contains(response, "Change username")
assert_contains(response, "You will be able to change your username again")
def test_account_username_renders_empty_history(user_client):
response = user_client.get(reverse("misago:account-username"))
assert_contains(response, "Changes history")
assert_contains(response, "Your account has no history of name changes.")
def test_account_username_renders_history_item(user_client, user):
orginal_username = user.username
user.set_username("John", user)
response = user_client.get(reverse("misago:account-username"))
assert_contains(response, "Changes history")
assert_contains(response, orginal_username)
assert_contains(response, "John")
assert_not_contains(response, "Your account has no history of name changes.")
@patch(
"misago.account.views.settings.paginate_queryset", side_effect=EmptyPageError(10)
)
def test_account_username_redirects_to_last_page_for_invalid_cursor(
mock_pagination, user_client, user
):
response = user_client.get(reverse("misago:account-username"))
assert response.status_code == 302
assert response["location"] == reverse("misago:account-username") + "?cursor=10"
mock_pagination.assert_called_once()
| 5,645
|
Python
|
.py
| 120
| 42.35
| 88
| 0.741499
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,853
|
test_account_email_confirm_change.py
|
rafalp_Misago/misago/account/tests/test_account_email_confirm_change.py
|
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...test import assert_contains
from ..emailchange import create_email_change_token
@override_dynamic_settings(enable_oauth2_client=True)
def test_account_email_confirm_change_returns_error_if_oauth_client_is_enabled(
user, user_client
):
response = user_client.get(
reverse(
"misago:account-email-confirm-change",
kwargs={"user_id": user.id, "token": "any"},
)
)
assert response.status_code == 404
def test_account_email_confirm_change_changes_email_if_user_is_guest(user, client):
new_email = "new@example.com"
token = create_email_change_token(user, new_email)
response = client.get(
reverse(
"misago:account-email-confirm-change",
kwargs={"user_id": user.id, "token": token},
)
)
assert_contains(response, "your email has been changed")
user.refresh_from_db()
assert user.email == new_email
def test_account_email_confirm_change_changes_email_if_user_is_authenticated(
user, user_client
):
new_email = "new@example.com"
token = create_email_change_token(user, new_email)
response = user_client.get(
reverse(
"misago:account-email-confirm-change",
kwargs={"user_id": user.id, "token": token},
)
)
assert_contains(response, "your email has been changed")
user.refresh_from_db()
assert user.email == new_email
def test_account_email_confirm_change_returns_error_if_user_id_is_invalid(user, client):
response = client.get(
reverse(
"misago:account-email-confirm-change",
kwargs={"user_id": user.id + 1, "token": "invalid"},
)
)
assert response.status_code == 404
def test_account_email_confirm_change_returns_error_if_token_is_invalid(user, client):
response = client.get(
reverse(
"misago:account-email-confirm-change",
kwargs={"user_id": user.id, "token": "invalid"},
)
)
assert_contains(response, "Mail change confirmation link is invalid.")
def test_account_email_confirm_change_returns_error_if_token_email_is_invalid(
admin, user, client
):
token = create_email_change_token(user, admin.email)
response = client.get(
reverse(
"misago:account-email-confirm-change",
kwargs={"user_id": user.id, "token": token},
)
)
assert_contains(response, "This e-mail address is not available.")
| 2,549
|
Python
|
.py
| 68
| 30.970588
| 88
| 0.662612
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,854
|
test_account_details.py
|
rafalp_Misago/misago/account/tests/test_account_details.py
|
from django.urls import reverse
from ...test import assert_contains, assert_has_success_message
def test_account_details_displays_login_page_for_guests(db, client):
response = client.get(reverse("misago:account-details"))
assert_contains(response, "Sign in to change your settings")
def test_account_details_renders_form(user_client):
response = user_client.get(reverse("misago:account-details"))
assert_contains(response, "Update profile details")
def test_account_details_form_clears_user_profile_fields(user, user_client):
response = user_client.post(reverse("misago:account-details"))
assert response.status_code == 302
assert_has_success_message(response, "Profile updated")
user.refresh_from_db()
assert user.profile_fields == {}
def test_account_details_form_sets_user_profile_fields(user, user_client):
response = user_client.post(
reverse("misago:account-details"),
{
"real_name": "John Doe",
"gender": "female",
"bio": "Bio history",
"twitter": "@example",
"skype": "skype",
"website": "http://example.com",
},
)
assert response.status_code == 302
assert_has_success_message(response, "Profile updated")
user.refresh_from_db()
assert user.profile_fields == {
"real_name": "John Doe",
"gender": "female",
"bio": "Bio history",
"twitter": "example",
"skype": "skype",
"website": "http://example.com",
}
def test_account_details_form_validates_profile_fields(user, user_client):
response = user_client.post(
reverse("misago:account-details"),
{
"real_name": "John Doe",
"gender": "female",
"bio": "",
"twitter": "invalid!",
"skype": "skype",
"extra": "skipped",
},
)
assert response.status_code == 200
assert_contains(response, "This is not a valid X handle.")
def test_account_details_form_skips_empty_profile_fields(user, user_client):
response = user_client.post(
reverse("misago:account-details"),
{
"real_name": "John Doe",
"gender": "female",
"bio": "",
"twitter": "@example",
"skype": "skype",
},
)
assert response.status_code == 302
assert_has_success_message(response, "Profile updated")
user.refresh_from_db()
assert user.profile_fields == {
"real_name": "John Doe",
"gender": "female",
"twitter": "example",
"skype": "skype",
}
def test_account_details_form_skips_extra_profile_fields(user, user_client):
response = user_client.post(
reverse("misago:account-details"),
{
"real_name": "John Doe",
"gender": "female",
"bio": "",
"twitter": "@example",
"skype": "skype",
"extra": "skipped",
},
)
assert response.status_code == 302
assert_has_success_message(response, "Profile updated")
user.refresh_from_db()
assert user.profile_fields == {
"real_name": "John Doe",
"gender": "female",
"twitter": "example",
"skype": "skype",
}
def test_account_details_form_sets_user_profile_fields_in_htmx(user, user_client):
response = user_client.post(
reverse("misago:account-details"),
{
"real_name": "John Doe",
"gender": "female",
"bio": "",
"twitter": "@example",
"skype": "skype",
"extra": "skipped",
},
headers={"hx-request": "true"},
)
assert_contains(response, "Profile updated")
user.refresh_from_db()
assert user.profile_fields == {
"real_name": "John Doe",
"gender": "female",
"twitter": "example",
"skype": "skype",
}
| 3,937
|
Python
|
.py
| 113
| 26.734513
| 82
| 0.582478
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,855
|
test_account_download_data.py
|
rafalp_Misago/misago/account/tests/test_account_download_data.py
|
from unittest.mock import patch
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...pagination.cursor import EmptyPageError
from ...test import (
assert_contains,
assert_has_success_message,
assert_has_warning_message,
assert_not_contains,
)
from ...users.datadownloads import request_user_data_download
from ...users.models import DataDownload
@override_dynamic_settings(allow_data_downloads=False)
def test_account_download_data_returns_error_if_data_downloads_are_disabled(db, client):
response = client.get(reverse("misago:account-download-data"))
assert response.status_code == 404
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_displays_login_page_for_guests(db, client):
response = client.get(reverse("misago:account-download-data"))
assert_contains(response, "Sign in to change your settings")
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_renders_form(user_client):
response = user_client.get(reverse("misago:account-download-data"))
assert_contains(response, "Download your data")
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_renders_form_in_htmx(user_client):
response = user_client.get(
reverse("misago:account-download-data"),
headers={"hx-request": "true"},
)
assert_contains(response, "Download your data")
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_requests_new_download(user, user_client):
response = user_client.post(reverse("misago:account-download-data"))
assert response.status_code == 302
assert_has_success_message(response, "Data download requested")
DataDownload.objects.get(user=user, requester=user)
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_requests_new_download_in_htmx(user, user_client):
response = user_client.post(
reverse("misago:account-download-data"),
headers={"hx-request": "true"},
)
assert_contains(response, "Data download requested")
assert_contains(response, "Preparing...")
assert_not_contains(response, "You have no data downloads.")
DataDownload.objects.get(user=user, requester=user)
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_displays_warning_on_multiple_download_requests(
user, user_client
):
download = request_user_data_download(user, user)
response = user_client.post(reverse("misago:account-download-data"))
assert response.status_code == 302
assert_has_warning_message(
response,
"You can't request a new data download before the previous one completes.",
)
assert not DataDownload.objects.exclude(id=download.id).exists()
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_displays_warning_on_multiple_download_requests_in_htmx(
user, user_client
):
download = request_user_data_download(user, user)
response = user_client.post(
reverse("misago:account-download-data"),
headers={"hx-request": "true"},
)
assert_contains(
response,
"You can't request a new data download before the previous one completes.",
)
assert not DataDownload.objects.exclude(id=download.id).exists()
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_renders_pending_download_request(user, user_client):
request_user_data_download(user, user)
response = user_client.get(reverse("misago:account-download-data"))
assert_contains(response, "Download your data")
assert_contains(response, "Preparing...")
assert_not_contains(response, "You have no data downloads.")
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_renders_processing_download_request(user, user_client):
download = request_user_data_download(user, user)
download.status = DataDownload.STATUS_PROCESSING
download.save()
response = user_client.get(reverse("misago:account-download-data"))
assert_contains(response, "Download your data")
assert_contains(response, "Preparing...")
assert_not_contains(response, "You have no data downloads.")
@override_dynamic_settings(allow_data_downloads=True)
def test_account_download_data_renders_expired_download_request(user, user_client):
download = request_user_data_download(user, user)
download.status = DataDownload.STATUS_EXPIRED
download.save()
response = user_client.get(reverse("misago:account-download-data"))
assert_contains(response, "Download your data")
assert_contains(response, "Download expired")
assert_not_contains(response, "You have no data downloads.")
@patch(
"misago.account.views.settings.paginate_queryset", side_effect=EmptyPageError(10)
)
def test_account_download_data_redirects_to_last_page_for_invalid_cursor(
mock_pagination, user_client, user
):
response = user_client.get(reverse("misago:account-download-data"))
assert response.status_code == 302
assert (
response["location"] == reverse("misago:account-download-data") + "?cursor=10"
)
mock_pagination.assert_called_once()
| 5,307
|
Python
|
.py
| 110
| 43.818182
| 88
| 0.756395
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,856
|
test_email_change_token.py
|
rafalp_Misago/misago/account/tests/test_email_change_token.py
|
import pytest
from django.test import override_settings
from ..emailchange import (
EmailChangeTokenError,
EmailChangeTokenErrorCode,
create_email_change_token,
read_email_change_token,
)
def test_email_change_token_can_be_created_and_unpacked(user):
new_email = "email@example.com"
token = create_email_change_token(user, new_email)
token_email = read_email_change_token(user, token)
assert new_email == token_email
def test_email_change_token_is_invalidated_by_user_email_change(user):
token = create_email_change_token(user, "email@example.com")
user.set_email("new@example.com")
user.save()
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, token)
assert str(exc_info.value) == "Mail change confirmation link has invalid signature."
assert exc_info.value.code == EmailChangeTokenErrorCode.SIGNATURE_INVALID
def test_read_email_change_token_raises_error_if_token_is_invalid(user):
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, "invalid")
assert str(exc_info.value) == "Mail change confirmation link is invalid."
assert exc_info.value.code == EmailChangeTokenErrorCode.TOKEN_INVALID
def test_email_change_token_is_invalidated_by_user_password_change(user):
token = create_email_change_token(user, "email@example.com")
user.set_password("changed")
user.save()
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, token)
assert str(exc_info.value) == "Mail change confirmation link has invalid signature."
assert exc_info.value.code == EmailChangeTokenErrorCode.SIGNATURE_INVALID
def test_email_change_token_is_invalidated_by_secret_key_change(user):
token = create_email_change_token(user, "email@example.com")
with override_settings(SECRET_KEY="NEW"):
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, token)
assert str(exc_info.value) == "Mail change confirmation link has invalid signature."
assert exc_info.value.code == EmailChangeTokenErrorCode.SIGNATURE_INVALID
def test_read_email_change_token_raises_error_if_token_is_missing_signature(user):
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, "-invalid")
assert (
str(exc_info.value) == "Mail change confirmation link is missing a signature."
)
assert exc_info.value.code == EmailChangeTokenErrorCode.SIGNATURE_MISSING
def test_read_email_change_token_raises_error_if_token_is_missing_payload(user):
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, "invalid-")
assert str(exc_info.value) == "Mail change confirmation link is missing a payload."
assert exc_info.value.code == EmailChangeTokenErrorCode.PAYLOAD_MISSING
def test_read_email_change_token_raises_error_if_token_signature_is_invalid(user):
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, "invalid-payload")
assert str(exc_info.value) == "Mail change confirmation link has invalid signature."
assert exc_info.value.code == EmailChangeTokenErrorCode.SIGNATURE_INVALID
@override_settings(MISAGO_EMAIL_CHANGE_TOKEN_EXPIRES=0)
def test_read_email_change_token_raises_error_if_token_is_expired(user):
token = create_email_change_token(user, "email@example.com")
with pytest.raises(EmailChangeTokenError) as exc_info:
read_email_change_token(user, token)
assert str(exc_info.value) == "Mail change confirmation link has expired."
assert exc_info.value.code == EmailChangeTokenErrorCode.TOKEN_EXPIRED
| 3,743
|
Python
|
.py
| 65
| 52.261538
| 88
| 0.75775
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,857
|
test_account_email.py
|
rafalp_Misago/misago/account/tests/test_account_email.py
|
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...test import assert_contains
@override_dynamic_settings(enable_oauth2_client=True)
def test_account_email_returns_error_if_oauth_client_is_enabled(db, client):
response = client.get(reverse("misago:account-email"))
assert response.status_code == 404
def test_account_email_displays_login_page_for_guests(db, client):
response = client.get(reverse("misago:account-email"))
assert_contains(response, "Sign in to change your settings")
def test_account_email_renders_form(user_client):
response = user_client.get(reverse("misago:account-email"))
assert_contains(response, "Change email address")
def test_account_email_form_sends_email_confirmation_link_on_change(
user_client, user_password, mailoutbox
):
response = user_client.post(
reverse("misago:account-email"),
{
"current_password": user_password,
"new_email": "new@example.com",
"confirm_email": "new@example.com",
},
)
assert response.status_code == 302
assert len(mailoutbox) == 1
def test_account_email_form_redirects_to_message_page_on_change(
user_client, user_password
):
response = user_client.post(
reverse("misago:account-email"),
{
"current_password": user_password,
"new_email": "new@example.com",
"confirm_email": "new@example.com",
},
)
assert response.status_code == 302
response = user_client.get(response.headers["location"])
assert_contains(response, "Confirm email address change")
def test_account_email_form_validates_current_password(user_client):
response = user_client.post(
reverse("misago:account-email"),
{
"current_password": "invalid",
"new_email": "new@example.com",
"confirm_email": "new@example.com",
},
)
assert response.status_code == 200
assert_contains(response, "Change email address")
assert_contains(response, "Password is incorrect.")
def test_account_email_form_validates_new_email(user_client, user_password):
response = user_client.post(
reverse("misago:account-email"),
{
"current_password": user_password,
"new_email": "invalid",
"confirm_email": "invalid",
},
)
assert response.status_code == 200
assert_contains(response, "Change email address")
assert_contains(response, "Enter a valid email address.")
def test_account_email_form_validates_email_is_new(user, user_client, user_password):
response = user_client.post(
reverse("misago:account-email"),
{
"current_password": user_password,
"new_email": user.email,
"confirm_email": user.email,
},
)
assert response.status_code == 200
assert_contains(response, "This email address is the same as the current one.")
def test_account_email_form_validates_new_emails_match(user_client, user_password):
response = user_client.post(
reverse("misago:account-email"),
{
"current_password": user_password,
"new_email": "new@example.com",
"confirm_email": "other@example.com",
},
)
assert response.status_code == 200
assert_contains(response, "Change email address")
assert_contains(response, "New email addresses don't match.")
def test_account_email_form_displays_message_page_on_change_in_htmx(
user_client, user_password
):
response = user_client.post(
reverse("misago:account-email"),
{
"current_password": user_password,
"new_email": "new@example.com",
"confirm_email": "new@example.com",
},
headers={"hx-request": "true"},
)
assert response.status_code == 200
assert_contains(response, "Confirm email address change")
| 3,976
|
Python
|
.py
| 101
| 32.277228
| 85
| 0.659398
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,858
|
test_account_delete.py
|
rafalp_Misago/misago/account/tests/test_account_delete.py
|
from unittest.mock import patch
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...test import assert_contains
@override_dynamic_settings(enable_oauth2_client=True, allow_delete_own_account=True)
def test_account_delete_returns_error_if_oauth_client_is_enabled(db, client):
response = client.get(reverse("misago:account-delete"))
assert response.status_code == 404
@override_dynamic_settings(enable_oauth2_client=False, allow_delete_own_account=False)
def test_account_delete_returns_error_if_own_account_deletion_is_disabled(db, client):
response = client.get(reverse("misago:account-delete"))
assert response.status_code == 404
@override_dynamic_settings(enable_oauth2_client=False, allow_delete_own_account=True)
def test_account_delete_displays_login_page_for_guests(db, client):
response = client.get(reverse("misago:account-delete"))
assert_contains(response, "Sign in to change your settings")
@override_dynamic_settings(enable_oauth2_client=False, allow_delete_own_account=True)
def test_account_delete_renders_form(user, user_client):
response = user_client.get(reverse("misago:account-delete"))
assert_contains(response, "This form allows you to delete your account.")
user.refresh_from_db()
@override_dynamic_settings(enable_oauth2_client=False, allow_delete_own_account=True)
def test_account_delete_displays_error_if_password_is_incorrect(user, user_client):
response = user_client.post(
reverse("misago:account-delete"), {"password": "incorrect"}
)
assert_contains(response, "This form allows you to delete your account.")
assert_contains(response, "Entered password is incorrect.")
user.refresh_from_db()
@override_dynamic_settings(enable_oauth2_client=False, allow_delete_own_account=True)
def test_account_delete_displays_error_if_user_account_is_protected(
admin, admin_client, user_password
):
response = admin_client.post(
reverse("misago:account-delete"), {"password": user_password}
)
assert_contains(response, "This form allows you to delete your account.")
assert_contains(response, "You can't delete your account")
admin.refresh_from_db()
@override_dynamic_settings(enable_oauth2_client=False, allow_delete_own_account=True)
@patch("misago.account.views.settings.delete_user")
def test_account_delete_calls_delete_user_task(
delete_user, user, user_client, user_password
):
response = user_client.post(
reverse("misago:account-delete"), {"password": user_password}
)
response.status_code == 302
delete_user.delay.assert_called_once_with(user.id)
@override_dynamic_settings(enable_oauth2_client=False, allow_delete_own_account=True)
@patch("misago.account.views.settings.delete_user")
def test_account_delete_redirects_to_delete_complete_page(
delete_user, user, user_client, user_password
):
response = user_client.post(
reverse("misago:account-delete"), {"password": user_password}
)
response.status_code == 302
response = user_client.get(response.headers["location"])
assert_contains(response, "User, your account is now being deleted.")
@patch("misago.account.views.settings.delete_user")
def test_account_delete_completed_view_returns_404_if_navigated_directly(user_client):
response = user_client.get(reverse("misago:account-delete-completed"))
response.status_code == 404
| 3,437
|
Python
|
.py
| 64
| 49.75
| 86
| 0.764337
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,859
|
test_available_username_changes.py
|
rafalp_Misago/misago/account/tests/test_available_username_changes.py
|
from dataclasses import dataclass
from datetime import timedelta
from django.utils import timezone
from ..namechanges import get_available_username_changes
@dataclass
class Permissions:
can_change_username: bool = False
username_changes_limit: int = 0
username_changes_expire: int = 0
username_changes_span: int = 0
def test_get_available_username_changes_doesnt_allow_name_change_if_no_permission(user):
options = get_available_username_changes(user, Permissions())
assert not options.can_change_username
assert options.unlimited is False
assert options.changes_left == 0
assert options.next_change is None
def test_get_available_username_changes_allows_unlimited_name_changes_without_wait(
user,
):
options = get_available_username_changes(
user, Permissions(can_change_username=True)
)
assert options.can_change_username
assert options.unlimited is True
assert options.changes_left is None
assert options.next_change is None
def test_get_available_username_changes_allows_unlimited_name_changes_without_wait_after_change(
user,
):
user.set_username("Bob", user)
options = get_available_username_changes(
user, Permissions(can_change_username=True)
)
assert options.can_change_username
assert options.unlimited is True
assert options.changes_left is None
assert options.next_change is None
def test_get_available_username_changes_counts_user_name_changes_to_the_limit(user):
user.set_username("Bob", user)
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=2,
),
)
assert options.can_change_username
assert options.unlimited is False
assert options.changes_left is 1
assert options.next_change is None
def test_get_available_username_changes_counts_recent_name_changes_to_the_limit(user):
user.set_username("Bob", user)
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=2,
username_changes_expire=1,
),
)
assert options.can_change_username
assert options.unlimited is False
assert options.changes_left is 1
assert options.next_change is None
def test_get_available_username_changes_doesnt_count_expired_name_changes_to_the_limit(
user,
):
change = user.set_username("Bob", user)
change.changed_on -= timedelta(hours=2)
change.save()
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=2,
username_changes_expire=1,
),
)
assert options.can_change_username
assert options.unlimited is False
assert options.changes_left is 2
assert options.next_change is None
def test_get_available_username_changes_doesnt_count_user_name_changes_by_other_users_to_the_limit(
admin, user
):
user.set_username("Bob", admin)
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=2,
),
)
assert options.can_change_username
assert options.unlimited is False
assert options.changes_left is 2
assert options.next_change is None
def test_get_available_username_changes_includes_span_in_next_change(user):
change = user.set_username("Bob", user)
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_span=1,
),
)
assert not options.can_change_username
assert options.unlimited is True
assert options.changes_left is None
assert options.next_change > change.changed_on
def test_get_available_username_changes_includes_span_in_past_next_change(user):
change = user.set_username("Bob", user)
change.changed_on -= timedelta(hours=2)
change.save()
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_span=1,
),
)
assert options.can_change_username
assert options.unlimited is True
assert options.changes_left is None
assert options.next_change > change.changed_on
assert options.next_change < timezone.now()
def test_get_available_username_changes_prevents_change_if_limit_is_met(
user,
):
user.set_username("Bob", user)
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=1,
),
)
assert not options.can_change_username
assert options.unlimited is False
assert options.changes_left == 0
assert options.next_change is None
def test_get_available_username_changes_prevents_change_if_limit_is_exceeded(
user,
):
user.set_username("Bob", user)
user.set_username("Dan", user)
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=1,
),
)
assert not options.can_change_username
assert options.unlimited is False
assert options.changes_left == 0
assert options.next_change is None
def test_get_available_username_changes_next_change_is_expiration_if_greater(
user,
):
first_change = user.set_username("Bob", user)
first_change.changed_on -= timedelta(hours=3)
first_change.save()
second_change = user.set_username("Dan", user)
second_change.changed_on -= timedelta(hours=2)
second_change.save()
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=2,
username_changes_expire=6,
username_changes_span=1,
),
)
assert not options.can_change_username
assert options.unlimited is False
assert options.changes_left == 0
assert options.next_change > first_change.changed_on
assert options.next_change > second_change.changed_on
assert options.next_change > timezone.now() + timedelta(hours=2)
def test_get_available_username_changes_next_change_is_span_if_greater(
user,
):
first_change = user.set_username("Bob", user)
first_change.changed_on -= timedelta(hours=2)
first_change.save()
second_change = user.set_username("Dan", user)
options = get_available_username_changes(
user,
Permissions(
can_change_username=True,
username_changes_limit=2,
username_changes_expire=3,
username_changes_span=5,
),
)
assert not options.can_change_username
assert options.unlimited is False
assert options.changes_left == 0
assert options.next_change > second_change.changed_on
assert options.next_change > timezone.now() + timedelta(hours=4)
| 7,082
|
Python
|
.py
| 202
| 28.653465
| 99
| 0.696952
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,860
|
test_account_password.py
|
rafalp_Misago/misago/account/tests/test_account_password.py
|
from django.urls import reverse
from ...conf.test import override_dynamic_settings
from ...test import assert_contains, assert_has_success_message
@override_dynamic_settings(enable_oauth2_client=True)
def test_account_password_returns_error_if_oauth_client_is_enabled(db, client):
response = client.get(reverse("misago:account-password"))
assert response.status_code == 404
def test_account_password_displays_login_page_for_guests(db, client):
response = client.get(reverse("misago:account-password"))
assert_contains(response, "Sign in to change your settings")
def test_account_password_renders_form(user_client):
response = user_client.get(reverse("misago:account-password"))
assert_contains(response, "Change password")
def test_account_password_form_changes_password(user, user_client, user_password):
response = user_client.post(
reverse("misago:account-password"),
{
"current_password": user_password,
"new_password": "l0r3m1psum",
"confirm_password": "l0r3m1psum",
},
)
assert response.status_code == 302
assert_has_success_message(response, "Password changed")
user.refresh_from_db()
assert user.check_password("l0r3m1psum")
def test_account_password_form_keeps_user_authenticated_on_change(
user_client, user_password
):
response = user_client.post(
reverse("misago:account-password"),
{
"current_password": user_password,
"new_password": "l0r3m1psum",
"confirm_password": "l0r3m1psum",
},
)
assert response.status_code == 302
assert_has_success_message(response, "Password changed")
response = user_client.get(reverse("misago:account-password"))
assert_contains(response, "Change password")
def test_account_password_form_sends_email_notification_on_change(
user_client, user_password, mailoutbox
):
response = user_client.post(
reverse("misago:account-password"),
{
"current_password": user_password,
"new_password": "l0r3m1psum",
"confirm_password": "l0r3m1psum",
},
)
assert response.status_code == 302
assert_has_success_message(response, "Password changed")
assert len(mailoutbox) == 1
def test_account_password_form_validates_current_password(
user, user_client, user_password
):
response = user_client.post(
reverse("misago:account-password"),
{
"current_password": "invalid",
"new_password": "l0r3m1psum",
"confirm_password": "l0r3m1psum",
},
)
assert response.status_code == 200
assert_contains(response, "Change password")
assert_contains(response, "Password is incorrect.")
user.refresh_from_db()
assert user.check_password(user_password)
def test_account_password_form_validates_new_password(user, user_client, user_password):
response = user_client.post(
reverse("misago:account-password"),
{
"current_password": user_password,
"new_password": "p",
"confirm_password": "p",
},
)
assert response.status_code == 200
assert_contains(response, "Change password")
assert_contains(response, "This password is too short.")
user.refresh_from_db()
assert user.check_password(user_password)
def test_account_password_form_validates_new_passwords_match(
user, user_client, user_password
):
response = user_client.post(
reverse("misago:account-password"),
{
"current_password": user_password,
"new_password": "l0r3m1psum",
"confirm_password": "l0r3m1psumdolor",
},
)
assert response.status_code == 200
assert_contains(response, "Change password")
assert_contains(response, "New passwords don't match.")
user.refresh_from_db()
assert user.check_password(user_password)
def test_account_password_form_changes_password_in_htmx(
user, user_client, user_password
):
response = user_client.post(
reverse("misago:account-password"),
{
"current_password": user_password,
"new_password": "l0r3m1psum",
"confirm_password": "l0r3m1psum",
},
headers={"hx-request": "true"},
)
assert_contains(response, "Password changed")
user.refresh_from_db()
assert user.check_password("l0r3m1psum")
| 4,463
|
Python
|
.py
| 116
| 31.681034
| 88
| 0.673536
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,861
|
test_account_preferences.py
|
rafalp_Misago/misago/account/tests/test_account_preferences.py
|
from django.urls import reverse
from ...test import assert_contains, assert_has_success_message
def test_account_preferences_displays_login_page_for_guests(db, client):
response = client.get(reverse("misago:account-preferences"))
assert_contains(response, "Sign in to change your settings")
def test_account_preferences_renders_form(user_client):
response = user_client.get(reverse("misago:account-preferences"))
assert_contains(response, "Change preferences")
def create_form_data(data: dict | None = None) -> dict:
default_data = {
"is_hiding_presence": "0",
"limits_private_thread_invites_to": "0",
"watch_started_threads": "0",
"watch_replied_threads": "0",
"watch_new_private_threads_by_followed": "0",
"watch_new_private_threads_by_other_users": "0",
"notify_new_private_threads_by_followed": "0",
"notify_new_private_threads_by_other_users": "0",
}
if data:
default_data.update(data)
return default_data
def test_account_preferences_form_updates_user_account(user, user_client):
response = user_client.post(
reverse("misago:account-preferences"),
create_form_data(
{
"is_hiding_presence": "1",
"limits_private_thread_invites_to": "1",
"watch_started_threads": "1",
"watch_replied_threads": "2",
"watch_new_private_threads_by_followed": "1",
"watch_new_private_threads_by_other_users": "2",
"notify_new_private_threads_by_followed": "1",
"notify_new_private_threads_by_other_users": "2",
}
),
)
assert response.status_code == 302
assert_has_success_message(response, "Preferences updated")
user.refresh_from_db()
assert user.is_hiding_presence
assert user.limits_private_thread_invites_to == 1
assert user.watch_started_threads == 1
assert user.watch_replied_threads == 2
assert user.watch_new_private_threads_by_followed == 1
assert user.watch_new_private_threads_by_other_users == 2
assert user.notify_new_private_threads_by_followed == 1
assert user.notify_new_private_threads_by_other_users == 2
def test_account_preferences_form_updates_user_account_in_htmx(user, user_client):
response = user_client.post(
reverse("misago:account-preferences"),
create_form_data(
{
"is_hiding_presence": "1",
"limits_private_thread_invites_to": "1",
"watch_started_threads": "1",
"watch_replied_threads": "2",
"watch_new_private_threads_by_followed": "1",
"watch_new_private_threads_by_other_users": "2",
"notify_new_private_threads_by_followed": "1",
"notify_new_private_threads_by_other_users": "2",
}
),
headers={"hx-request": "true"},
)
assert_contains(response, "Preferences updated")
user.refresh_from_db()
assert user.is_hiding_presence
assert user.limits_private_thread_invites_to == 1
assert user.watch_started_threads == 1
assert user.watch_replied_threads == 2
assert user.watch_new_private_threads_by_followed == 1
assert user.watch_new_private_threads_by_other_users == 2
assert user.notify_new_private_threads_by_followed == 1
assert user.notify_new_private_threads_by_other_users == 2
| 3,476
|
Python
|
.py
| 76
| 37.092105
| 82
| 0.642034
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,862
|
test_validate.py
|
rafalp_Misago/misago/account/tests/test_validate.py
|
import json
from django.urls import reverse
def test_validate_views_return_400_if_method_is_not_post(db, client):
response = client.get(reverse("misago:account-validate-username"))
assert response.status_code == 400
def test_validate_views_return_400_if_value_is_missing(db, client):
response = client.post(reverse("misago:account-validate-username"))
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": ["'value' can't be empty."],
}
def test_validate_views_return_400_if_value_is_empty(db, client):
response = client.post(reverse("misago:account-validate-username"), {"value": ""})
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": ["'value' can't be empty."],
}
def test_validate_views_return_400_if_user_is_not_valid_int(db, client):
response = client.post(
reverse("misago:account-validate-username"), {"value": "Joh", "user": "invalid"}
)
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": ["'user' must be a positive integer."],
}
def test_validate_views_return_400_if_user_is_not_positive_int(db, client):
response = client.post(
reverse("misago:account-validate-username"), {"value": "Joh", "user": "-5"}
)
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": ["'user' must be a positive integer."],
}
def test_validate_username_view_returns_validation_errors(db, client):
response = client.post(
reverse("misago:account-validate-username"), {"value": "Jo!"}
)
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": [
"Username can only contain Latin alphabet letters, digits, and an underscore sign."
],
}
def test_validate_username_view_returns_no_errors_for_valid_name(db, client):
response = client.post(
reverse("misago:account-validate-username"), {"value": "Valid"}
)
assert response.status_code == 200
assert json.loads(response.content) == {"errors": []}
def test_validate_username_view_validates_username_availability(db, client, user):
response = client.post(
reverse("misago:account-validate-username"), {"value": user.username}
)
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": ["This username is not available."]
}
def test_validate_username_view_validates_username_availability_for_user(
db, client, user
):
response = client.post(
reverse("misago:account-validate-username"),
{"value": user.username, "user": str(user.id)},
)
assert response.status_code == 200
assert json.loads(response.content) == {"errors": []}
def test_validate_email_view_returns_validation_errors(db, client):
response = client.post(
reverse("misago:account-validate-email"), {"value": "invalid"}
)
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": ["Enter a valid e-mail address."],
}
def test_validate_email_view_returns_no_errors_for_valid_email(db, client):
response = client.post(
reverse("misago:account-validate-email"), {"value": "valid@example.com"}
)
assert response.status_code == 200
assert json.loads(response.content) == {"errors": []}
def test_validate_email_view_validates_email_availability(db, client, user):
response = client.post(
reverse("misago:account-validate-email"), {"value": user.email}
)
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": ["This e-mail address is not available."]
}
def test_validate_email_view_validates_email_availability_for_user(db, client, user):
response = client.post(
reverse("misago:account-validate-email"),
{"value": user.email, "user": str(user.id)},
)
assert response.status_code == 200
assert json.loads(response.content) == {"errors": []}
def test_validate_password_view_returns_validation_errors(db, client):
response = client.post(reverse("misago:account-validate-password"), {"value": "p"})
assert response.status_code == 400
assert json.loads(response.content) == {
"errors": [
"This password is too short. It must contain at least 7 characters."
],
}
def test_validate_password_view_returns_no_errors_for_valid_password(db, client):
response = client.post(
reverse("misago:account-validate-password"), {"value": "l0r3m1p5um"}
)
assert response.status_code == 200
assert json.loads(response.content) == {"errors": []}
| 4,766
|
Python
|
.py
| 109
| 38.073394
| 95
| 0.675962
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,863
|
apps.py
|
rafalp_Misago/misago/forms/apps.py
|
from django.apps import AppConfig
class MisagoFormsConfig(AppConfig):
name = "misago.forms"
label = "misago_forms"
verbose_name = "Misago Forms"
| 159
|
Python
|
.py
| 5
| 28
| 35
| 0.743421
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,864
|
formset.py
|
rafalp_Misago/misago/forms/formset.py
|
from functools import cached_property
from django.forms import Form
class Formset:
"""Formset that combines forms of any type.
Used by views and templates that display multiple forms that should be validated
together.
"""
def __init__(self):
self.forms: dict[str, Form] = {}
def __getitem__(self, form_id: str):
return self.forms[form_id]
def get_forms(self) -> list[Form]:
return list(self.forms.values())
def add_form(self, form: Form, *, append: bool = True):
if not form.prefix:
raise ValueError("Forms added to 'Formset' must define a prefix.")
if form.prefix in self.forms:
raise ValueError(
f"Form with prefix '{form.prefix}' is already a part of this formset."
)
if append:
self.forms[form.prefix] = form
else:
forms: dict[str, Form] = {}
forms[form.prefix] = form
forms.update(self.forms)
self.forms = forms
@cached_property
def is_bound(self) -> bool:
return all([form.is_bound for form in self.forms.values()])
def is_valid(self) -> bool:
return all([form.is_valid() for form in self.forms.values()])
def non_field_errors(self):
errors = []
for form in self.forms.values():
errors += form.non_field_errors()
return errors
| 1,414
|
Python
|
.py
| 37
| 29.621622
| 86
| 0.603372
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,865
|
misago_forms.py
|
rafalp_Misago/misago/forms/templatetags/misago_forms.py
|
from django import template
from django.forms.boundfield import BoundField, BoundWidget
register = template.Library()
@register.filter
def checkedhtml(bound_widget: BoundWidget) -> str:
return " checked" if bound_widget.data.get("selected") else ""
@register.filter
def selectedhtml(bound_widget: BoundWidget) -> str:
return " selected" if bound_widget.data.get("selected") else ""
@register.filter
def requiredhtml(field_or_widget: BoundField | BoundWidget) -> str:
if isinstance(field_or_widget, BoundField) and field_or_widget.field.required:
return " required"
if isinstance(field_or_widget, BoundWidget) and field_or_widget.data["attrs"].get(
"required"
):
return " required"
return ""
| 748
|
Python
|
.py
| 18
| 37.388889
| 86
| 0.739251
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,866
|
test_formset.py
|
rafalp_Misago/misago/forms/tests/test_formset.py
|
import pytest
from django import forms
from ..formset import Formset
class UserForm(forms.Form):
name = forms.CharField(max_length=10)
def clean(self):
data = super().clean()
if data.get("name") == "Bob":
raise forms.ValidationError("Name can't be Bob!")
return data
class AgeForm(forms.Form):
age = forms.IntegerField(min_value=18)
def clean(self):
data = super().clean()
if data.get("age") == 42:
raise forms.ValidationError("Age can't be 42!")
return data
def test_basic_formset_add_form_adds_form_with_prefix():
form = UserForm(prefix="user")
formset = Formset()
formset.add_form(form)
assert formset["user"] is form
def test_basic_formset_add_form_raises_value_error_if_form_is_missing_prefix():
with pytest.raises(ValueError) as exc_info:
formset = Formset()
formset.add_form(UserForm())
assert "must define a prefix" in str(exc_info.value)
def test_basic_formset_add_form_raises_value_error_if_form_with_prefix_already_exists():
with pytest.raises(ValueError) as exc_info:
formset = Formset()
formset.add_form(UserForm(prefix="user"))
formset.add_form(AgeForm(prefix="user"))
assert "is already a part of this formset" in str(exc_info.value)
def test_basic_formset_is_bound_is_true_if_all_forms_are_bound():
formset = Formset()
formset.add_form(UserForm({"user-name": "Alice"}, prefix="user"))
formset.add_form(AgeForm({"age-age": 12}, prefix="age"))
assert formset.is_bound
def test_basic_formset_is_bound_is_false_if_some_forms_are_bound():
formset = Formset()
formset.add_form(UserForm({"user-name": "Alice"}, prefix="user"))
formset.add_form(AgeForm(prefix="age"))
assert not formset.is_bound
def test_basic_formset_is_bound_is_false_if_no_forms_are_bound():
formset = Formset()
formset.add_form(UserForm(prefix="user"))
formset.add_form(AgeForm(prefix="age"))
assert not formset.is_bound
def test_basic_formset_is_valid_is_true_if_all_forms_are_valid():
formset = Formset()
formset.add_form(UserForm({"user-name": "Alice"}, prefix="user"))
formset.add_form(AgeForm({"age-age": 22}, prefix="age"))
assert formset.is_valid()
def test_basic_formset_is_valid_is_false_if_some_forms_are_valid():
formset = Formset()
formset.add_form(UserForm({"user-name": "Alice"}, prefix="user"))
formset.add_form(AgeForm({"age-age": 12}, prefix="age"))
assert not formset.is_valid()
def test_basic_formset_is_valid_is_false_if_no_forms_are_valid():
formset = Formset()
formset.add_form(UserForm({"user-name": "Alice" * 10}, prefix="user"))
formset.add_form(AgeForm({"age-age": 12}, prefix="age"))
assert not formset.is_valid()
def test_basic_formset_non_field_errors_returns_empty_if_forms_have_no_non_field_errors():
formset = Formset()
formset.add_form(UserForm({"user-name": "Alice"}, prefix="user"))
formset.add_form(AgeForm({"age-age": 22}, prefix="age"))
assert formset.is_valid()
assert formset.non_field_errors() == []
def test_basic_formset_non_field_errors_returns_list_if_any_form_has_no_non_field_errors():
formset = Formset()
formset.add_form(UserForm({"user-name": "Bob"}, prefix="user"))
formset.add_form(AgeForm({"age-age": 22}, prefix="age"))
assert not formset.is_valid()
assert len(formset.non_field_errors()) == 1
def test_basic_formset_non_field_errors_returns_list_of_all_non_field_errors():
formset = Formset()
formset.add_form(UserForm({"user-name": "Bob"}, prefix="user"))
formset.add_form(AgeForm({"age-age": 42}, prefix="age"))
assert not formset.is_valid()
assert len(formset.non_field_errors()) == 2
| 3,776
|
Python
|
.py
| 81
| 41.246914
| 91
| 0.684441
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,867
|
models.py
|
rafalp_Misago/misago/socialauth/models.py
|
from django.db import models
from .providers import providers
class SocialAuthProvider(models.Model):
provider = models.CharField(primary_key=True, max_length=30)
button_text = models.CharField(max_length=255, null=True, blank=True)
button_color = models.CharField(max_length=7, null=True, blank=True)
settings = models.JSONField(default=dict)
is_active = models.BooleanField(default=False)
order = models.IntegerField(default=0)
class Meta:
ordering = ["order"]
def __str__(self):
return providers.get_name(self.provider)
| 576
|
Python
|
.py
| 13
| 39.230769
| 73
| 0.734767
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,868
|
pipeline.py
|
rafalp_Misago/misago/socialauth/pipeline.py
|
# pylint: disable=keyword-arg-before-vararg
import json
from django.contrib.auth import get_user_model
from django.db import IntegrityError
from django.http import JsonResponse
from django.shortcuts import render
from django.urls import reverse
from django.utils.translation import pgettext
from social_core.pipeline.partial import partial
from unidecode import unidecode
from ..core.exceptions import SocialAuthBanned, SocialAuthFailed
from ..legal.models import Agreement
from ..users.bans import get_request_ip_ban, get_user_ban
from ..users.forms.register import SocialAuthRegisterForm
from ..users.models import Ban
from ..users.registration import (
get_registration_result_json,
save_user_agreements,
send_welcome_email,
)
from ..users.setupnewuser import setup_new_user
from ..users.validators import (
ValidationError,
validate_email,
validate_new_registration,
validate_username,
)
from .providers import providers
User = get_user_model()
def validate_ip_not_banned(strategy, details, backend, user=None, *args, **kwargs):
"""
Pipeline step that interrupts pipeline if found user is non-staff and IP banned
"""
if not user or user.is_misago_admin:
return None
ban = get_request_ip_ban(strategy.request)
if ban:
hydrated_ban = Ban(
check_type=Ban.IP, user_message=ban["message"], expires_on=ban["expires_on"]
)
raise SocialAuthBanned(backend, hydrated_ban)
def validate_user_not_banned(strategy, details, backend, user=None, *args, **kwargs):
"""Pipeline step that interrupts pipeline if found user is non-staff and banned"""
if not user or user.is_misago_admin:
return None
user_ban = get_user_ban(user, strategy.request.cache_versions)
if user_ban:
raise SocialAuthBanned(backend, user_ban)
def perpare_username(username):
return "".join(filter(str.isalnum, unidecode(username)))
def associate_by_email(strategy, details, backend, user=None, *args, **kwargs):
"""If user with e-mail from provider exists in database and is active,
this step authenticates them.
"""
enable_step = strategy.setting("ASSOCIATE_BY_EMAIL", default=False, backend=backend)
if user or not enable_step:
return None
email = details.get("email")
if not email:
return None
try:
user = User.objects.get_by_email(email)
except User.DoesNotExist:
return None
backend_name = providers.get_name(backend.name)
if not user.is_active:
raise SocialAuthFailed(
backend,
pgettext(
"social auth",
"The e-mail address associated with your %(backend)s account is not available for use on this site.",
)
% {"backend": backend_name},
)
if user.requires_activation_by_admin:
raise SocialAuthFailed(
backend,
pgettext(
"social auth",
"Your account has to be activated by site administrator before you will be able to sign in with %(backend)s.",
)
% {"backend": backend_name},
)
return {"user": user, "is_new": False}
def get_username(strategy, details, backend, user=None, *args, **kwargs):
"""Resolve valid username for use in new account"""
if user:
return None
settings = strategy.request.settings
username = perpare_username(details.get("username", ""))
full_name = perpare_username(details.get("full_name", ""))
first_name = perpare_username(details.get("first_name", ""))
last_name = perpare_username(details.get("last_name", ""))
names_to_try = [username, first_name]
if username:
names_to_try.append(username)
if first_name:
names_to_try.append(first_name)
if last_name:
# if first name is taken, try first name + first char of last name
names_to_try.append(first_name + last_name[0])
if full_name:
names_to_try.append(full_name)
username_length_max = settings.username_length_max
for name in names_to_try:
if len(name) > username_length_max:
names_to_try.append(name[:username_length_max])
for name in filter(bool, names_to_try):
try:
validate_username(settings, name)
return {"clean_username": name}
except ValidationError:
pass
def create_user(strategy, details, backend, user=None, *args, **kwargs):
"""Aggressively attempt to register and sign in new user"""
if user:
return None
request = strategy.request
settings = request.settings
email = details.get("email")
username = kwargs.get("clean_username")
if not email or not username:
return None
try:
validate_email(email)
validate_new_registration(request, {"email": email, "username": username})
except ValidationError:
return None
activation_kwargs = {}
if settings.account_activation == "admin":
activation_kwargs = {"requires_activation": User.ACTIVATION_ADMIN}
new_user = User.objects.create_user(
username, email, joined_from_ip=request.user_ip, **activation_kwargs
)
setup_new_user(settings, new_user)
send_welcome_email(request, new_user)
return {"user": new_user, "is_new": True}
@partial
def create_user_with_form(strategy, details, backend, user=None, *args, **kwargs):
"""
create_user lets user confirm account creation by entering final username or email
"""
if user:
return None
request = strategy.request
settings = request.settings
backend_name = providers.get_name(backend.name)
if request.method == "POST":
try:
request_data = json.loads(request.body)
except (TypeError, ValueError):
request_data = request.POST.copy()
form = SocialAuthRegisterForm(
request_data, request=request, agreements=Agreement.objects.get_agreements()
)
if not form.is_valid():
return JsonResponse(form.errors, status=400)
email_verified = form.cleaned_data["email"] == details.get("email")
activation_kwargs = {}
if settings.account_activation == "admin":
activation_kwargs = {"requires_activation": User.ACTIVATION_ADMIN}
elif settings.account_activation == "user" and not email_verified:
activation_kwargs = {"requires_activation": User.ACTIVATION_USER}
try:
new_user = User.objects.create_user(
form.cleaned_data["username"],
form.cleaned_data["email"],
joined_from_ip=request.user_ip,
**activation_kwargs
)
setup_new_user(settings, new_user)
except IntegrityError:
return JsonResponse(
{
"__all__": pgettext(
"social auth", "Please try resubmitting the form."
)
},
status=400,
)
save_user_agreements(new_user, form)
send_welcome_email(request, new_user)
return {"user": new_user, "is_new": True}
request.frontend_context["SOCIAL_AUTH_FORM"] = {
"backend_name": backend_name,
"step": "register",
"email": details.get("email"),
"username": kwargs.get("clean_username"),
"url": reverse("misago:social-complete", kwargs={"backend": backend.name}),
}
return render(request, "misago/socialauth.html", {"backend_name": backend_name})
@partial
def require_activation(
strategy, details, backend, user=None, is_new=False, *args, **kwargs
):
if not user:
# Social auth pipeline has entered corrupted state
# Remove partial auth state and redirect user to beginning
partial_token = strategy.session.get("partial_pipeline_token")
if partial_token:
strategy.clean_partial_pipeline(partial_token)
return None
if not user.requires_activation:
return None
request = strategy.request
backend_name = providers.get_name(backend.name)
response_data = get_registration_result_json(user)
response_data.update({"step": "done", "backend_name": backend_name})
if request.method == "POST":
# we are carrying on from requestration request
return JsonResponse(response_data)
request.frontend_context["SOCIAL_AUTH_FORM"] = response_data
request.frontend_context["SOCIAL_AUTH_FORM"].update(
{"url": reverse("misago:social-complete", kwargs={"backend": backend.name})}
)
return render(request, "misago/socialauth.html", {"backend_name": backend_name})
| 8,773
|
Python
|
.py
| 216
| 33.018519
| 126
| 0.659722
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,869
|
urls.py
|
rafalp_Misago/misago/socialauth/urls.py
|
from django.urls import path
from . import views
urlpatterns = [
path("login/<str:backend>/", views.auth, name="social-login"),
path("complete/<str:backend>/", views.complete, name="social-complete"),
]
| 214
|
Python
|
.py
| 6
| 32.833333
| 76
| 0.712195
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,870
|
apps.py
|
rafalp_Misago/misago/socialauth/apps.py
|
from django.apps import AppConfig
from social_core.backends.discord import DiscordOAuth2
from social_core.backends.facebook import FacebookOAuth2
from social_core.backends.github import GithubOAuth2
from social_core.backends.google import GoogleOAuth2
from social_core.backends.twitter import TwitterOAuth
from .providers import providers
class MisagoSocialAuthConfig(AppConfig):
name = "misago.socialauth"
label = "misago_socialauth"
verbose_name = "Misago Social Auth"
def ready(self):
# Register default providers
from .admin.forms import (
DiscordForm,
FacebookForm,
GitHubForm,
GoogleForm,
TwitterForm,
)
providers.add(
provider="discord",
name="Discord",
auth_backend=DiscordOAuth2,
settings={"scope": ["email"]},
admin_form=DiscordForm,
admin_template="misago/admin/socialauth/form.html",
)
providers.add(
provider="facebook",
name="Facebook",
auth_backend=FacebookOAuth2,
settings={"scope": ["email"]},
admin_form=FacebookForm,
admin_template="misago/admin/socialauth/form.html",
)
providers.add(
provider="github",
name="GitHub",
auth_backend=GithubOAuth2,
settings={"scope": ["read:user", "user:email"]},
admin_form=GitHubForm,
admin_template="misago/admin/socialauth/form.html",
)
providers.add(
provider="google-oauth2",
name="Google",
auth_backend=GoogleOAuth2,
admin_form=GoogleForm,
admin_template="misago/admin/socialauth/form.html",
)
providers.add(
provider="twitter",
name="X",
auth_backend=TwitterOAuth,
admin_form=TwitterForm,
admin_template="misago/admin/socialauth/form.html",
)
| 2,023
|
Python
|
.py
| 58
| 24.896552
| 63
| 0.606633
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,871
|
context_processors.py
|
rafalp_Misago/misago/socialauth/context_processors.py
|
from django.urls import reverse
def preload_socialauth_json(request):
request.frontend_context.update(
{"SOCIAL_AUTH": get_enabled_social_auth_providers(request.socialauth)}
)
return {}
def get_enabled_social_auth_providers(socialauth):
providers = []
for provider in socialauth.values():
providers.append(
{
"pk": provider["pk"],
"name": provider["name"],
"button_text": provider["button_text"],
"button_color": provider["button_color"],
"url": reverse(
"misago:social-login", kwargs={"backend": provider["pk"]}
),
}
)
return providers
| 730
|
Python
|
.py
| 21
| 24.571429
| 78
| 0.559659
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,872
|
cache.py
|
rafalp_Misago/misago/socialauth/cache.py
|
from django.core.cache import cache
from . import SOCIALAUTH_CACHE
from ..cache.versions import invalidate_cache
def get_socialauth_cache(cache_versions):
key = get_cache_key(cache_versions)
return cache.get(key)
def set_socialauth_cache(cache_versions, socialauth):
key = get_cache_key(cache_versions)
cache.set(key, socialauth)
def get_cache_key(cache_versions):
return "%s_%s" % (SOCIALAUTH_CACHE, cache_versions[SOCIALAUTH_CACHE])
def clear_socialauth_cache():
invalidate_cache(SOCIALAUTH_CACHE)
| 533
|
Python
|
.py
| 13
| 37.461538
| 73
| 0.771037
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,873
|
enabledproviders.py
|
rafalp_Misago/misago/socialauth/enabledproviders.py
|
from .cache import get_socialauth_cache, set_socialauth_cache
from .models import SocialAuthProvider
from .providers import providers
def get_enabled_providers(cache_versions):
data = get_socialauth_cache(cache_versions)
if data is None:
data = get_providers_from_db()
set_socialauth_cache(cache_versions, data)
for provider, options in data.items():
options["auth_backend"] = providers.get_auth_backend(provider)
return data
def get_providers_from_db():
data = {}
for provider in SocialAuthProvider.objects.filter(is_active=True):
data[provider.pk] = {
"pk": provider.pk,
"provider": provider.provider,
"name": providers.get_name(provider.pk),
"settings": get_provider_settings(provider),
"auth_backend": None,
"button_text": provider.button_text,
"button_color": provider.button_color,
}
return data
def get_provider_settings(provider):
settings = {}
if providers.get_settings(provider.pk):
for key, value in providers.get_settings(provider.pk).items():
settings[key.upper()] = value
if provider.settings:
for key, value in provider.settings.items():
settings[key.upper()] = value
return settings
| 1,313
|
Python
|
.py
| 33
| 32.30303
| 70
| 0.663265
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,874
|
middleware.py
|
rafalp_Misago/misago/socialauth/middleware.py
|
from django.utils.functional import SimpleLazyObject
from .enabledproviders import get_enabled_providers
def socialauth_providers_middleware(get_response):
"""Sets request.socialauth attribute with dict of setup social auth providers."""
def middleware(request):
def lazily_get_enabled_providers():
return get_enabled_providers(request.cache_versions)
request.socialauth = SimpleLazyObject(lazily_get_enabled_providers)
return get_response(request)
return middleware
| 521
|
Python
|
.py
| 10
| 45.7
| 85
| 0.772277
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,875
|
strategy.py
|
rafalp_Misago/misago/socialauth/strategy.py
|
from django.core.exceptions import PermissionDenied
from social_django.strategy import DjangoStrategy
class MisagoStrategy(DjangoStrategy):
def setting(self, name, default=None, backend=None):
if backend:
backend_settings = self.request.socialauth[backend.name]["settings"]
if name in backend_settings:
return backend_settings[name]
return super().setting(name, default, backend)
def authenticate(self, backend, *args, **kwargs):
kwargs["strategy"] = self
kwargs["storage"] = self.storage
kwargs["backend"] = backend
try:
return backend.authenticate(*args, **kwargs)
except PermissionDenied:
pass
| 730
|
Python
|
.py
| 17
| 34.117647
| 80
| 0.668079
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,876
|
providers.py
|
rafalp_Misago/misago/socialauth/providers.py
|
class Providers:
def __init__(self):
self._dict = {}
self._list = []
def dict(self):
return self._dict
def list(self):
return self._list
def is_registered(self, provider):
return provider in self._dict
def add(
self, *, provider, name, auth_backend, settings=None, admin_form, admin_template
):
data = {
"provider": provider,
"name": name,
"auth_backend": auth_backend,
"settings": settings or {},
"admin_form": admin_form,
"admin_template": admin_template,
}
if provider != auth_backend.name:
raise ValueError(
f"Provider's key '{provider}' is not the same as backend's name "
f"attribute: '{auth_backend.name}'"
)
self._dict[provider] = data
self._list.append(data)
self._list = sorted(self._list, key=lambda k: k["name"])
def get_name(self, provider):
return self._dict.get(provider)["name"]
def get_auth_backend(self, provider):
return self._dict.get(provider)["auth_backend"]
def get_settings(self, provider):
return self._dict.get(provider)["settings"]
def get_admin_form_class(self, provider):
return self._dict.get(provider)["admin_form"]
def get_admin_template_name(self, provider):
return self._dict.get(provider)["admin_template"]
providers = Providers()
| 1,487
|
Python
|
.py
| 40
| 28.15
| 88
| 0.585774
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,877
|
views.py
|
rafalp_Misago/misago/socialauth/views.py
|
from django.contrib.auth import REDIRECT_FIELD_NAME, login
from django.core.exceptions import PermissionDenied
from django.http import Http404
from django.urls import reverse
from django.utils.translation import pgettext
from django.views.decorators.cache import never_cache
from django.views.decorators.csrf import csrf_exempt
from social_core.actions import do_auth, do_complete
from social_django.views import _do_login
from social_django.utils import load_strategy
def get_provider_from_request(request, backend):
try:
return request.socialauth[backend]
except KeyError:
raise Http404()
def social_auth_view(f):
def social_auth_view_wrapper(request, backend, *args, **kwargs):
if request.settings.enable_oauth2_client:
raise PermissionDenied(
pgettext(
"social auth",
"This feature has been disabled. Please use %(provider)s to sign in.",
)
% {"provider": request.settings.oauth2_provider}
)
provider = get_provider_from_request(request, backend)
request.strategy = load_strategy(request)
backend_class = provider["auth_backend"]
request.backend = backend_class(
request.strategy,
reverse("misago:social-complete", kwargs={"backend": backend}),
)
return f(request, backend, *args, **kwargs)
return social_auth_view_wrapper
@never_cache
@social_auth_view
def auth(request, backend):
return do_auth(request.backend, redirect_name=REDIRECT_FIELD_NAME)
@never_cache
@csrf_exempt
@social_auth_view
def complete(request, backend, *args, **kwargs):
return do_complete(
request.backend,
do_login,
user=request.user,
redirect_name=REDIRECT_FIELD_NAME,
request=request,
*args,
**kwargs
)
def do_login(backend, user, social_user):
user.backend = "misago.users.authbackends.MisagoBackend"
login(backend.strategy.request, user)
| 2,033
|
Python
|
.py
| 54
| 30.833333
| 90
| 0.692621
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,878
|
0003_rename_google_to_google_oauth.py
|
rafalp_Misago/misago/socialauth/migrations/0003_rename_google_to_google_oauth.py
|
# Generated by Django 2.2.3 on 2019-11-10 14:32
from django.db import migrations
def rename_google_provider(apps, _):
SocialAuthProvider = apps.get_model("misago_socialauth", "SocialAuthProvider")
SocialAuthProvider.objects.filter(provider="google").update(
provider="google-oauth2"
)
class Migration(migrations.Migration):
dependencies = [("misago_socialauth", "0002_cache_version")]
operations = [migrations.RunPython(rename_google_provider)]
| 479
|
Python
|
.py
| 10
| 43.5
| 82
| 0.75594
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,879
|
0001_initial.py
|
rafalp_Misago/misago/socialauth/migrations/0001_initial.py
|
# Generated by Django 2.2.1 on 2019-06-16 13:39
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="SocialAuthProvider",
fields=[
(
"provider",
models.CharField(max_length=30, primary_key=True, serialize=False),
),
(
"button_text",
models.CharField(blank=True, max_length=255, null=True),
),
("button_color", models.CharField(blank=True, max_length=7, null=True)),
(
"settings",
models.JSONField(default=dict),
),
("is_active", models.BooleanField(default=False)),
("order", models.IntegerField(default=0)),
],
options={"ordering": ["order"]},
)
]
| 1,003
|
Python
|
.py
| 28
| 22.357143
| 88
| 0.489691
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,880
|
0002_cache_version.py
|
rafalp_Misago/misago/socialauth/migrations/0002_cache_version.py
|
from django.db import migrations
from .. import SOCIALAUTH_CACHE
from ...cache.operations import StartCacheVersioning
class Migration(migrations.Migration):
dependencies = [
("misago_socialauth", "0001_initial"),
("misago_cache", "0001_initial"),
]
operations = [StartCacheVersioning(SOCIALAUTH_CACHE)]
| 335
|
Python
|
.py
| 9
| 32.666667
| 57
| 0.736025
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,881
|
conftest.py
|
rafalp_Misago/misago/socialauth/tests/conftest.py
|
import pytest
from ..models import SocialAuthProvider
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(
provider="facebook",
is_active=True,
order=0,
settings={"key": "test-key", "secret": "test-secret"},
)
@pytest.fixture
def disabled_provider(db):
return SocialAuthProvider.objects.create(
provider="google", is_active=False, order=0
)
| 425
|
Python
|
.py
| 15
| 23.266667
| 62
| 0.693827
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,882
|
test_social_pipeline.py
|
rafalp_Misago/misago/socialauth/tests/test_social_pipeline.py
|
import json
from unittest.mock import Mock
import pytest
from django.contrib.auth import get_user_model
from django.core import mail
from django.test import RequestFactory
from social_core.backends.github import GithubOAuth2
from social_django.utils import load_strategy
from ...acl.useracl import get_user_acl
from ...categories.proxy import CategoriesProxy
from ...conf.dynamicsettings import DynamicSettings
from ...conf.test import override_dynamic_settings
from ...conftest import get_cache_versions
from ...core.exceptions import SocialAuthBanned, SocialAuthFailed
from ...legal.models import Agreement
from ...permissions.proxy import UserPermissionsProxy
from ...users.models import AnonymousUser, Ban, BanCache
from ...users.test import UserTestCase
from ..pipeline import (
associate_by_email,
create_user,
create_user_with_form,
get_username,
require_activation,
validate_ip_not_banned,
validate_user_not_banned,
)
User = get_user_model()
def create_request(user_ip="0.0.0.0", data=None):
factory = RequestFactory()
if data is None:
request = factory.get("/")
else:
request = factory.post(
"/", data=json.dumps(data), content_type="application/json"
)
request.include_frontend_context = True
request.cache_versions = get_cache_versions()
request.frontend_context = {}
request.socialauth = {}
request.session = {}
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.user_ip = user_ip
request.is_htmx = False
return request
def create_strategy():
request = create_request()
return load_strategy(request=request)
class MockStrategy:
def __init__(self, user_ip="0.0.0.0"):
self.cleaned_partial_token = None
self.request = create_request(user_ip)
def clean_partial_pipeline(self, token):
self.cleaned_partial_token = token
class PipelineTestCase(UserTestCase):
def get_initial_user(self):
self.user = self.get_authenticated_user()
def assertNewUserIsCorrect(
self, new_user, form_data=None, activation=None, email_verified=False
):
self.assertFalse(new_user.has_usable_password())
self.assertIn("Welcome", mail.outbox[0].subject)
if form_data:
self.assertEqual(new_user.email, form_data["email"])
self.assertEqual(new_user.username, form_data["username"])
if activation == "none":
self.assertEqual(new_user.requires_activation, User.ACTIVATION_NONE)
if activation == "user":
if email_verified:
self.assertEqual(new_user.requires_activation, User.ACTIVATION_NONE)
else:
self.assertEqual(new_user.requires_activation, User.ACTIVATION_USER)
if activation == "admin":
self.assertEqual(new_user.requires_activation, User.ACTIVATION_ADMIN)
self.assertEqual(new_user.audittrail_set.count(), 1)
def assertJsonResponseEquals(self, response, value):
response_content = response.content.decode("utf-8")
response_json = json.loads(response_content)
self.assertEqual(response_json, value)
class AssociateByEmailTests(PipelineTestCase):
def test_skip_if_user_is_already_set(self):
"""pipeline step is skipped if user was found by previous step"""
result = associate_by_email(Mock(), {}, GithubOAuth2, self.user)
self.assertIsNone(result)
def test_skip_if_no_email_passed(self):
"""pipeline step is skipped if no email was passed"""
result = associate_by_email(Mock(), {}, GithubOAuth2)
self.assertIsNone(result)
def test_skip_if_user_with_email_not_found(self):
"""pipeline step is skipped if no email was passed"""
result = associate_by_email(Mock(), {"email": "not@found.com"}, GithubOAuth2)
self.assertIsNone(result)
def test_raise_if_user_is_inactive(self):
"""pipeline raises if user was inactive"""
strategy = Mock(setting=Mock(return_value=True))
self.user.is_active = False
self.user.save()
try:
associate_by_email(strategy, {"email": self.user.email}, GithubOAuth2)
self.fail("associate_by_email should raise SocialAuthFailed")
except SocialAuthFailed as e:
self.assertEqual(
e.message,
(
"The e-mail address associated with your GitHub account "
"is not available for use on this site."
),
)
def test_raise_if_user_needs_admin_activation(self):
"""pipeline raises if user needs admin activation"""
strategy = Mock(setting=Mock(return_value=True))
self.user.requires_activation = User.ACTIVATION_ADMIN
self.user.save()
try:
associate_by_email(strategy, {"email": self.user.email}, GithubOAuth2)
self.fail("associate_by_email should raise SocialAuthFailed")
except SocialAuthFailed as e:
self.assertEqual(
e.message,
(
"Your account has to be activated by site administrator "
"before you will be able to sign in with GitHub."
),
)
def test_no_user_is_returned_if_pipeline_is_disabled(self):
strategy = Mock(setting=Mock(return_value=False))
result = associate_by_email(strategy, {"email": self.user.email}, GithubOAuth2)
self.assertIsNone(result)
strategy.setting.assert_called_once_with(
"ASSOCIATE_BY_EMAIL", default=False, backend=GithubOAuth2
)
def test_return_user(self):
"""pipeline returns user if email was found"""
strategy = Mock(setting=Mock(return_value=True))
result = associate_by_email(strategy, {"email": self.user.email}, GithubOAuth2)
self.assertEqual(result, {"user": self.user, "is_new": False})
def test_return_user_email_inactive(self):
"""pipeline returns user even if they didn't activate their account manually"""
strategy = Mock(setting=Mock(return_value=True))
self.user.requires_activation = User.ACTIVATION_USER
self.user.save()
result = associate_by_email(strategy, {"email": self.user.email}, GithubOAuth2)
self.assertEqual(result, {"user": self.user, "is_new": False})
class CreateUser(PipelineTestCase):
def test_skip_if_user_is_set(self):
"""pipeline step is skipped if user was passed"""
result = create_user(MockStrategy(), {}, GithubOAuth2(), user=self.user)
self.assertIsNone(result)
def test_skip_if_no_email_passed(self):
"""pipeline step is skipped if no email was passed"""
result = create_user(
MockStrategy(), {}, GithubOAuth2(), clean_username="TestBob"
)
self.assertIsNone(result)
def test_skip_if_no_clean_username_passed(self):
"""pipeline step is skipped if cleaned username wasnt passed"""
result = create_user(
MockStrategy(), {"email": "hello@example.com"}, GithubOAuth2()
)
self.assertIsNone(result)
def test_skip_if_email_is_taken(self):
"""pipeline step is skipped if email was taken"""
result = create_user(
MockStrategy(),
{"email": self.user.email},
GithubOAuth2(),
clean_username="NewUser",
)
self.assertIsNone(result)
@override_dynamic_settings(account_activation="none")
def test_user_created_no_activation(self):
"""pipeline step creates active user for valid data and disabled activation"""
result = create_user(
MockStrategy(),
{"email": "new@example.com"},
GithubOAuth2(),
clean_username="NewUser",
)
new_user = User.objects.get(email="new@example.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertEqual(new_user.username, "NewUser")
self.assertNewUserIsCorrect(new_user, email_verified=True, activation="none")
@override_dynamic_settings(account_activation="user")
def test_user_created_activation_by_user(self):
"""pipeline step creates active user for valid data and user activation"""
result = create_user(
MockStrategy(),
{"email": "new@example.com"},
GithubOAuth2(),
clean_username="NewUser",
)
new_user = User.objects.get(email="new@example.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertEqual(new_user.username, "NewUser")
self.assertNewUserIsCorrect(new_user, email_verified=True, activation="user")
@override_dynamic_settings(account_activation="admin")
def test_user_created_activation_by_admin(self):
"""pipeline step creates in user for valid data and admin activation"""
result = create_user(
MockStrategy(),
{"email": "new@example.com"},
GithubOAuth2(),
clean_username="NewUser",
)
new_user = User.objects.get(email="new@example.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertEqual(new_user.username, "NewUser")
self.assertNewUserIsCorrect(new_user, email_verified=True, activation="admin")
class CreateUserWithFormTests(PipelineTestCase):
def setUp(self):
super().setUp()
Agreement.objects.invalidate_cache()
def tearDown(self):
super().tearDown()
Agreement.objects.invalidate_cache()
def test_skip_if_user_is_set(self):
"""pipeline step is skipped if user was passed"""
request = create_request()
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={},
backend=backend,
user=self.user,
pipeline_index=1,
)
self.assertEqual(result, {})
def test_renders_form_if_not_post(self):
"""pipeline step renders form if not POST"""
request = create_request()
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
response = create_user_with_form(
strategy=strategy, details={}, backend=backend, user=None, pipeline_index=1
)
self.assertContains(response, "GitHub")
def test_empty_data_rejected(self):
"""form rejects empty data"""
request = create_request(data={})
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
response = create_user_with_form(
strategy=strategy, details={}, backend=backend, user=None, pipeline_index=1
)
self.assertEqual(response.status_code, 400)
self.assertJsonResponseEquals(
response,
{
"email": ["This field is required."],
"username": ["This field is required."],
},
)
def test_taken_data_rejected(self):
"""form rejects taken data"""
request = create_request(
data={"email": self.user.email, "username": self.user.username}
)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
response = create_user_with_form(
strategy=strategy, details={}, backend=backend, user=None, pipeline_index=1
)
self.assertEqual(response.status_code, 400)
self.assertJsonResponseEquals(
response,
{
"email": ["This e-mail address is not available."],
"username": ["This username is not available."],
},
)
@override_dynamic_settings(account_activation="none")
def test_user_created_no_activation_verified_email(self):
"""active user is created for verified email and activation disabled"""
form_data = {"email": "social@auth.com", "username": "SocialUser"}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={"email": form_data["email"]},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertNewUserIsCorrect(
new_user, form_data, activation="none", email_verified=True
)
@override_dynamic_settings(account_activation="none")
def test_user_created_no_activation_nonverified_email(self):
"""active user is created for non-verified email and activation disabled"""
form_data = {"email": "social@auth.com", "username": "SocialUser"}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={"email": ""},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertNewUserIsCorrect(
new_user, form_data, activation="none", email_verified=False
)
@override_dynamic_settings(account_activation="user")
def test_user_created_activation_by_user_verified_email(self):
"""active user is created for verified email and activation by user"""
form_data = {"email": "social@auth.com", "username": "SocialUser"}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={"email": form_data["email"]},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertNewUserIsCorrect(
new_user, form_data, activation="user", email_verified=True
)
@override_dynamic_settings(account_activation="user")
def test_user_created_activation_by_user_nonverified_email(self):
"""inactive user is created for non-verified email and activation by user"""
form_data = {"email": "social@auth.com", "username": "SocialUser"}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={"email": ""},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertNewUserIsCorrect(
new_user, form_data, activation="user", email_verified=False
)
@override_dynamic_settings(account_activation="admin")
def test_user_created_activation_by_admin_verified_email(self):
"""inactive user is created for verified email and activation by admin"""
form_data = {"email": "social@auth.com", "username": "SocialUser"}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={"email": form_data["email"]},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertNewUserIsCorrect(
new_user, form_data, activation="admin", email_verified=True
)
@override_dynamic_settings(account_activation="admin")
def test_user_created_activation_by_admin_nonverified_email(self):
"""inactive user is created for non-verified email and activation by admin"""
form_data = {"email": "social@auth.com", "username": "SocialUser"}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={"email": ""},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertNewUserIsCorrect(
new_user, form_data, activation="admin", email_verified=False
)
def test_form_check_agreement(self):
"""social register checks agreement"""
form_data = {"email": "social@auth.com", "username": "SocialUser"}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
agreement = Agreement.objects.create(
type=Agreement.TYPE_TOS, text="Lorem ipsum", is_active=True
)
response = create_user_with_form(
strategy=strategy,
details={"email": form_data["email"]},
backend=backend,
user=None,
pipeline_index=1,
)
self.assertEqual(response.status_code, 400)
self.assertJsonResponseEquals(
response, {"terms_of_service": ["This agreement is required."]}
)
# invalid agreement id
form_data = {
"email": "social@auth.com",
"username": "SocialUser",
"terms_of_service": agreement.id + 1,
}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
response = create_user_with_form(
strategy=strategy,
details={"email": form_data["email"]},
backend=backend,
user=None,
pipeline_index=1,
)
self.assertEqual(response.status_code, 400)
self.assertJsonResponseEquals(
response, {"terms_of_service": ["This agreement is required."]}
)
# valid agreement id
form_data = {
"email": "social@auth.com",
"username": "SocialUser",
"terms_of_service": agreement.id,
}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = create_user_with_form(
strategy=strategy,
details={"email": form_data["email"]},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertEqual(new_user.agreements, [agreement.id])
self.assertEqual(new_user.useragreement_set.count(), 1)
def test_form_ignore_inactive_agreement(self):
"""social register ignores inactive agreement"""
form_data = {
"email": "social@auth.com",
"username": "SocialUser",
"terms_of_service": None,
}
request = create_request(data=form_data)
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
Agreement.objects.create(
type=Agreement.TYPE_TOS, text="Lorem ipsum", is_active=False
)
result = create_user_with_form(
strategy=strategy,
details={"email": form_data["email"]},
backend=backend,
user=None,
pipeline_index=1,
)
new_user = User.objects.get(email="social@auth.com")
self.assertEqual(result, {"user": new_user, "is_new": True})
self.assertEqual(new_user.agreements, [])
self.assertEqual(new_user.useragreement_set.count(), 0)
class GetUsernameTests(PipelineTestCase):
def test_skip_if_user_is_set(self):
"""pipeline step is skipped if user was passed"""
strategy = create_strategy()
result = get_username(strategy, {}, None, user=self.user)
self.assertIsNone(result)
def test_skip_if_no_names(self):
"""pipeline step is skipped if API returned no names"""
strategy = create_strategy()
result = get_username(strategy, {}, None)
self.assertIsNone(result)
def test_resolve_to_username(self):
"""pipeline step resolves username"""
strategy = create_strategy()
result = get_username(strategy, {"username": "BobBoberson"}, None)
self.assertEqual(result, {"clean_username": "BobBoberson"})
def test_normalize_username(self):
"""pipeline step normalizes username"""
strategy = create_strategy()
result = get_username(strategy, {"username": "Błop Błoperson"}, None)
self.assertEqual(result, {"clean_username": "BlopBloperson"})
def test_resolve_to_first_name(self):
"""pipeline attempts to use first name because username is taken"""
strategy = create_strategy()
details = {"username": self.user.username, "first_name": "Błob"}
result = get_username(strategy, details, None)
self.assertEqual(result, {"clean_username": "Blob"})
def test_dont_resolve_to_last_name(self):
"""pipeline will not fallback to last name because username is taken"""
strategy = create_strategy()
details = {"username": self.user.username, "last_name": "Błob"}
result = get_username(strategy, details, None)
self.assertIsNone(result)
def test_resolve_to_first_last_name_first_char(self):
"""pipeline will construct username from first name and first char of surname"""
strategy = create_strategy()
details = {"first_name": self.user.username, "last_name": "Błob"}
result = get_username(strategy, details, None)
self.assertEqual(result, {"clean_username": self.user.username + "B"})
def test_dont_resolve_to_banned_name(self):
"""pipeline will not resolve to banned name"""
strategy = create_strategy()
Ban.objects.create(banned_value="*Admin*", check_type=Ban.USERNAME)
details = {"username": "Misago Admin", "first_name": "Błob"}
result = get_username(strategy, details, None)
self.assertEqual(result, {"clean_username": "Blob"})
def test_resolve_full_name(self):
"""pipeline will resolve to full name"""
strategy = create_strategy()
Ban.objects.create(banned_value="*Admin*", check_type=Ban.USERNAME)
details = {"username": "Misago Admin", "full_name": "Błob Błopo"}
result = get_username(strategy, details, None)
self.assertEqual(result, {"clean_username": "BlobBlopo"})
def test_resolve_to_cut_name(self):
"""pipeline will resolve cut too long name on second pass"""
strategy = create_strategy()
details = {"username": "Abrakadabrapokuskonstantynopolitańczykowianeczkatrzy"}
result = get_username(strategy, details, None)
self.assertEqual(result, {"clean_username": "Abrakadabrapok"})
class RequireActivationTests(PipelineTestCase):
def setUp(self):
super().setUp()
self.user.requires_activation = User.ACTIVATION_ADMIN
self.user.save()
def test_skip_if_user_not_set(self):
"""pipeline step is skipped if user is not set"""
request = create_request()
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = require_activation(
strategy=strategy, details={}, backend=backend, user=None, pipeline_index=1
)
self.assertEqual(result, {})
def test_partial_token_if_user_not_set_no_showstopper(self):
"""pipeline step handles set session token if user is not set"""
request = create_request()
strategy = load_strategy(request=request)
strategy.request.session["partial_pipeline_token"] = "test-token"
backend = GithubOAuth2(strategy, "/")
require_activation(
strategy=strategy, details={}, backend=backend, user=None, pipeline_index=1
)
def test_skip_if_user_is_active(self):
"""pipeline step is skipped if user is active"""
self.user.requires_activation = User.ACTIVATION_NONE
self.user.save()
self.assertFalse(self.user.requires_activation)
request = create_request()
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
result = require_activation(
strategy=strategy,
details={},
backend=backend,
user=self.user,
pipeline_index=1,
)
self.assertEqual(result, {})
def test_pipeline_returns_html_response_on_get(self):
"""pipeline step renders http response for GET request and inactive user"""
request = create_request()
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
response = require_activation(
strategy=strategy,
details={},
backend=backend,
user=self.user,
pipeline_index=1,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response["content-type"], "text/html; charset=utf-8")
def test_pipeline_returns_json_response_on_post(self):
"""pipeline step renders json response for POST request and inactive user"""
request = create_request(data={"username": "anything"})
strategy = load_strategy(request=request)
backend = GithubOAuth2(strategy, "/")
response = require_activation(
strategy=strategy,
details={},
backend=backend,
user=self.user,
pipeline_index=1,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response["content-type"], "application/json")
self.assertJsonResponseEquals(
response,
{
"step": "done",
"backend_name": "GitHub",
"activation": "admin",
"email": "test@user.com",
"username": "TestUser",
},
)
def test_validate_ip_not_banned_step_returns_none_if_user_not_set(db):
result = validate_ip_not_banned(MockStrategy(user_ip="188.1.2.3"), {}, GithubOAuth2)
assert result is None
def test_validate_ip_not_banned_does_nothing_if_user_ip_is_not_banned(user):
result = validate_ip_not_banned(
MockStrategy(user_ip="188.1.2.3"), {}, GithubOAuth2, user
)
assert result is None
def test_validate_ip_not_banned_step_raises_error_if_user_ip_is_banned(user):
Ban.objects.create(banned_value="188.*", check_type=Ban.IP)
with pytest.raises(SocialAuthBanned) as exc_info:
validate_ip_not_banned(
MockStrategy(user_ip="188.1.2.3"), {}, GithubOAuth2, user
)
assert isinstance(exc_info.value.ban, Ban)
def test_validate_ip_not_banned_step_does_nothing_if_banned_user_is_admin(admin):
Ban.objects.create(banned_value="188.*", check_type=Ban.IP)
result = validate_ip_not_banned(
MockStrategy(user_ip="188.1.2.3"), {}, GithubOAuth2, admin
)
assert result is None
def test_validate_user_not_banned_step_returns_none_if_user_not_set(db):
result = validate_user_not_banned(MockStrategy(), {}, GithubOAuth2)
assert result is None
def test_validate_user_not_banned_does_nothing_if_user_is_not_banned(user):
result = validate_user_not_banned(MockStrategy(), {}, GithubOAuth2, user)
assert result is None
def test_validate_user_not_banned_step_raises_error_if_user_is_banned(user):
Ban.objects.create(banned_value=user.username, check_type=Ban.USERNAME)
with pytest.raises(SocialAuthBanned) as exc_info:
validate_user_not_banned(MockStrategy(), {}, GithubOAuth2, user)
assert isinstance(exc_info.value.ban, BanCache)
def test_validate_user_not_banned_step_does_nothing_if_banned_user_is_admin(admin):
Ban.objects.create(banned_value=admin.username, check_type=Ban.USERNAME)
result = validate_user_not_banned(MockStrategy(), {}, GithubOAuth2, admin)
assert result is None
| 29,340
|
Python
|
.py
| 649
| 35.978428
| 88
| 0.636991
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,883
|
test_socialauth_middleware.py
|
rafalp_Misago/misago/socialauth/tests/test_socialauth_middleware.py
|
from unittest.mock import Mock
import pytest
from django.utils.functional import SimpleLazyObject
from ..middleware import socialauth_providers_middleware
@pytest.fixture
def get_response():
return Mock()
class PlainRequest:
pass
@pytest.fixture
def plain_request():
return PlainRequest()
def test_middleware_sets_attr_on_request(db, get_response, plain_request):
middleware = socialauth_providers_middleware(get_response)
middleware(plain_request)
assert hasattr(plain_request, "socialauth")
def test_attr_set_by_middleware_on_request_is_lazy_object(
db, get_response, plain_request
):
middleware = socialauth_providers_middleware(get_response)
middleware(plain_request)
assert isinstance(plain_request.socialauth, SimpleLazyObject)
def test_middleware_calls_get_response(db, get_response, plain_request):
middleware = socialauth_providers_middleware(get_response)
middleware(plain_request)
get_response.assert_called_once()
def test_middleware_is_not_reading_from_db(
db, get_response, plain_request, django_assert_num_queries
):
with django_assert_num_queries(0):
middleware = socialauth_providers_middleware(get_response)
middleware(plain_request)
def test_middleware_is_not_reading_from_cache(db, mocker, get_response, plain_request):
cache_get = mocker.patch("django.core.cache.cache.get")
middleware = socialauth_providers_middleware(get_response)
middleware(plain_request)
cache_get.assert_not_called()
| 1,521
|
Python
|
.py
| 37
| 37.135135
| 87
| 0.781719
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,884
|
test_begin_auth.py
|
rafalp_Misago/misago/socialauth/tests/test_begin_auth.py
|
from django.urls import reverse
from ...conf.test import override_dynamic_settings
def test_view_begins_social_auth_for_provider(client, provider):
response = client.get(
reverse("misago:social-login", kwargs={"backend": provider.pk})
)
assert response.status_code == 302
@override_dynamic_settings(
enable_oauth2_client=True,
oauth2_provider="Lorem",
)
def test_view_returns_403_when_oauth2_is_enabled(client, provider):
response = client.get(
reverse("misago:social-login", kwargs={"backend": provider.pk})
)
assert response.status_code == 403
def test_view_returns_404_for_disabled_provider(client, disabled_provider):
response = client.get(
reverse("misago:social-login", kwargs={"backend": disabled_provider.pk})
)
assert response.status_code == 404
def test_view_returns_404_for_undefined_provider(db, client):
response = client.get(
reverse("misago:social-login", kwargs={"backend": "undefined"})
)
assert response.status_code == 404
| 1,038
|
Python
|
.py
| 26
| 35.192308
| 80
| 0.717846
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,885
|
test_providers.py
|
rafalp_Misago/misago/socialauth/tests/test_providers.py
|
import pytest
from ..providers import Providers
class Mock:
def __init__(self, name):
self.name = name
@pytest.fixture
def auth_backend():
return Mock(name="facebook")
@pytest.fixture
def providers(auth_backend):
obj = Providers()
obj.add(
provider="facebook",
name="Facebook",
auth_backend=auth_backend,
settings={"scope": ["email"]},
admin_form=True,
admin_template="form.html",
)
return obj
def test_provider_can_be_added_to_providers(auth_backend):
providers = Providers()
providers.add(
provider="facebook",
name="Facebook",
auth_backend=auth_backend,
settings={"scope": ["email"]},
admin_form=True,
admin_template="form.html",
)
assert providers.dict() == {
"facebook": {
"provider": "facebook",
"name": "Facebook",
"auth_backend": auth_backend,
"settings": {"scope": ["email"]},
"admin_form": True,
"admin_template": "form.html",
}
}
assert providers.list() == [
{
"provider": "facebook",
"name": "Facebook",
"auth_backend": auth_backend,
"settings": {"scope": ["email"]},
"admin_form": True,
"admin_template": "form.html",
}
]
def test_adding_provider_fails_if_provider_key_is_different_from_backend_name(
auth_backend,
):
providers = Providers()
with pytest.raises(ValueError):
providers.add(
provider="facebook-oauth",
name="Facebook",
auth_backend=auth_backend,
settings={"scope": ["email"]},
admin_form=True,
admin_template="form.html",
)
assert providers.dict() == {}
assert providers.list() == []
def test_providers_list_is_resorted_when_new_provider_is_added(providers, auth_backend):
other_auth_backend = Mock(name="auth")
providers.add(
provider="auth",
name="Auth",
auth_backend=other_auth_backend,
admin_form=True,
admin_template="form.html",
)
assert providers.list() == [
{
"provider": "auth",
"name": "Auth",
"auth_backend": other_auth_backend,
"settings": {},
"admin_form": True,
"admin_template": "form.html",
},
{
"provider": "facebook",
"name": "Facebook",
"auth_backend": auth_backend,
"settings": {"scope": ["email"]},
"admin_form": True,
"admin_template": "form.html",
},
]
def test_util_returns_true_for_existing_provider(providers):
assert providers.is_registered("facebook") is True
def test_util_returns_false_for_nonexisting_provider(providers):
assert providers.is_registered("github") is False
def test_getter_returns_given_provider_name(providers):
assert providers.get_name("facebook") == "Facebook"
def test_getter_returns_given_provider_auth_backend(providers, auth_backend):
assert providers.get_auth_backend("facebook") is auth_backend
def test_getter_returns_given_provider_settings(providers):
assert providers.get_settings("facebook") == {"scope": ["email"]}
def test_getter_returns_given_provider_admin_form_class(providers):
assert providers.get_admin_form_class("facebook") is True
def test_getter_returns_given_provider_admin_template_name(providers):
assert providers.get_admin_template_name("facebook") == "form.html"
| 3,603
|
Python
|
.py
| 106
| 26.066038
| 88
| 0.60225
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,886
|
test_context_processor.py
|
rafalp_Misago/misago/socialauth/tests/test_context_processor.py
|
from unittest.mock import Mock
from ..context_processors import preload_socialauth_json
def test_context_processor_sets_socialauth_entry_in_frontend_context():
request = Mock(frontend_context={}, socialauth={})
preload_socialauth_json(request)
assert "SOCIAL_AUTH" in request.frontend_context
| 308
|
Python
|
.py
| 6
| 47.833333
| 71
| 0.792642
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,887
|
test_getting_enabled_providers.py
|
rafalp_Misago/misago/socialauth/tests/test_getting_enabled_providers.py
|
from unittest.mock import Mock
import pytest
from .. import SOCIALAUTH_CACHE
from ..enabledproviders import get_enabled_providers, get_provider_settings
from ..models import SocialAuthProvider
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(
provider="facebook", is_active=True, order=0
)
def test_enabled_providers_are_read_from_db_if_cache_is_not_available(
db, mocker, cache_versions, django_assert_num_queries
):
mocker.patch("django.core.cache.cache.get", return_value=None)
with django_assert_num_queries(1):
get_enabled_providers(cache_versions)
def test_enabled_providers_are_loaded_from_cache_if_it_is_set(
db, mocker, cache_versions, django_assert_num_queries
):
cache_get = mocker.patch("django.core.cache.cache.get", return_value={})
with django_assert_num_queries(0):
get_enabled_providers(cache_versions)
cache_get.assert_called_once()
def test_enabled_providers_cache_is_set_if_none_exists(db, mocker, cache_versions):
cache_set = mocker.patch("django.core.cache.cache.set")
mocker.patch("django.core.cache.cache.get", return_value=None)
get_enabled_providers(cache_versions)
cache_set.assert_called_once()
def test_enabled_providers_cache_is_not_set_if_it_already_exists(
db, mocker, cache_versions, django_assert_num_queries
):
cache_set = mocker.patch("django.core.cache.cache.set")
mocker.patch("django.core.cache.cache.get", return_value={})
with django_assert_num_queries(0):
get_enabled_providers(cache_versions)
cache_set.assert_not_called()
def test_enabled_providers_cache_key_includes_cache_name_and_version(
db, mocker, cache_versions
):
cache_set = mocker.patch("django.core.cache.cache.set")
mocker.patch("django.core.cache.cache.get", return_value=None)
get_enabled_providers(cache_versions)
cache_key = cache_set.call_args[0][0]
assert SOCIALAUTH_CACHE in cache_key
assert cache_versions[SOCIALAUTH_CACHE] in cache_key
def test_enabled_providers_are_returned_as_dict(provider, mocker, cache_versions):
mocker.patch("django.core.cache.cache.set")
mocker.patch("django.core.cache.cache.get", return_value=None)
providers = get_enabled_providers(cache_versions)
assert provider.pk in providers
def test_enabled_providers_dict_includes_settings(provider, mocker, cache_versions):
mocker.patch("django.core.cache.cache.set")
mocker.patch("django.core.cache.cache.get", return_value=None)
providers = get_enabled_providers(cache_versions)
assert providers[provider.pk]["settings"]
def test_enabled_providers_dict_includes_auth_backend(provider, mocker, cache_versions):
mocker.patch("django.core.cache.cache.set")
mocker.patch("django.core.cache.cache.get", return_value=None)
providers = get_enabled_providers(cache_versions)
assert providers[provider.pk]["auth_backend"]
def test_provider_settings_keys_are_capitalized():
provider = Mock(pk="google-oauth2", settings={"key": "text-key"})
settings = get_provider_settings(provider)
assert settings == {"KEY": "text-key"}
def test_provider_settings_are_merged_from_model_and_defaults():
provider = Mock(pk="facebook", settings={"key": "text-key"})
settings = get_provider_settings(provider)
assert settings == {"SCOPE": ["email"], "KEY": "text-key"}
| 3,381
|
Python
|
.py
| 68
| 45.352941
| 88
| 0.747871
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,888
|
ordering.py
|
rafalp_Misago/misago/socialauth/admin/ordering.py
|
from ..models import SocialAuthProvider
def get_next_free_order():
last = SocialAuthProvider.objects.filter(is_active=True).last()
if last:
return last.order + 1
return 0
| 193
|
Python
|
.py
| 6
| 27.5
| 67
| 0.718919
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,889
|
__init__.py
|
rafalp_Misago/misago/socialauth/admin/__init__.py
|
from django.urls import path
from django.utils.translation import pgettext_lazy
from .views import (
DisableSocialAuthProvider,
EditSocialAuthProvider,
MoveDownSocialAuthProvider,
MoveUpSocialAuthProvider,
SocialAuthProvidersList,
)
class MisagoAdminExtension:
def register_urlpatterns(self, urlpatterns):
# Social auth providers
urlpatterns.namespace("social-auth/", "socialauth", "settings")
urlpatterns.patterns(
"settings:socialauth",
path("", SocialAuthProvidersList.as_view(), name="index"),
path(
"edit/<slug:pk>/",
EditSocialAuthProvider.as_view(),
name="edit",
),
path(
"down/<slug:pk>/",
MoveDownSocialAuthProvider.as_view(),
name="down",
),
path("up/<slug:pk>/", MoveUpSocialAuthProvider.as_view(), name="up"),
path(
"disable/<slug:pk>/",
DisableSocialAuthProvider.as_view(),
name="disable",
),
)
def register_navigation_nodes(self, site):
site.add_node(
name=pgettext_lazy("admin node", "Social login"),
description=pgettext_lazy(
"admin node",
"Enable users to sign on and login using their social profile.",
),
parent="settings",
namespace="socialauth",
)
| 1,494
|
Python
|
.py
| 43
| 23.883721
| 81
| 0.565308
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,890
|
views.py
|
rafalp_Misago/misago/socialauth/admin/views.py
|
from django.contrib import messages
from django.utils.translation import pgettext_lazy
from ...admin.views import generic
from ..cache import clear_socialauth_cache
from ..models import SocialAuthProvider
from ..providers import providers
class SocialAuthProviderAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:settings:socialauth:index"
model = SocialAuthProvider
form_class = None
templates_dir = "misago/admin/socialauth"
message_404 = pgettext_lazy(
"admin social auth providers", "Requested social login provider does not exist."
)
def get_target(self, request, kwargs):
queryset = SocialAuthProvider.objects.filter(is_active=True)
if self.is_atomic:
queryset = queryset.select_for_update()
return queryset.get(pk=kwargs["pk"])
def get_queryset(self):
return super().get_queryset().filter(is_active=True)
class SocialAuthProvidersList(SocialAuthProviderAdmin, generic.ListView):
def process_context(self, request, context):
active_providers = [i.pk for i in context["items"]]
context["inactive_providers"] = []
for provider in providers.list():
if provider["provider"] not in active_providers:
context["inactive_providers"].append(provider)
return context
class EditSocialAuthProvider(SocialAuthProviderAdmin, generic.ModelFormView):
def get_target(self, request, kwargs):
try:
return SocialAuthProvider.objects.get(provider=kwargs["pk"])
except SocialAuthProvider.DoesNotExist:
if not providers.is_registered(kwargs["pk"]):
raise
return SocialAuthProvider(provider=kwargs["pk"])
def get_form_class(self, request, target):
return providers.get_admin_form_class(target.provider)
def get_form(self, form_class, request, target):
if request.method == "POST":
return form_class(request.POST, instance=target, request=request)
return form_class(instance=target, initial=target.settings, request=request)
def get_template_name(self, request, target):
return providers.get_admin_template_name(target.provider)
def handle_form(self, form, request, target):
form.save()
clear_socialauth_cache()
message = pgettext_lazy(
"admin social auth providers", "Login with %(provider)s has been updated."
)
messages.success(request, message % {"provider": target})
class DisableSocialAuthProvider(SocialAuthProviderAdmin, generic.ButtonView):
def button_action(self, request, target):
target.is_active = False
target.save(update_fields=["is_active"])
clear_socialauth_cache()
message = pgettext_lazy(
"admin social auth providers", "Login with %(provider)s has been disabled."
)
messages.success(request, message % {"provider": target})
class MoveDownSocialAuthProvider(SocialAuthProviderAdmin, generic.ButtonView):
def button_action(self, request, target):
try:
other_target = SocialAuthProvider.objects.filter(
is_active=True, order__gt=target.order
)
other_target = other_target.earliest("order")
except SocialAuthProvider.DoesNotExist:
other_target = None
if other_target:
other_target.order, target.order = target.order, other_target.order
other_target.save(update_fields=["order"])
target.save(update_fields=["order"])
clear_socialauth_cache()
message = pgettext_lazy(
"admin social auth providers",
"Login with %(provider)s has been moved after %(other)s.",
)
targets_names = {"provider": target, "other": other_target}
messages.success(request, message % targets_names)
class MoveUpSocialAuthProvider(SocialAuthProviderAdmin, generic.ButtonView):
def button_action(self, request, target):
try:
other_target = SocialAuthProvider.objects.filter(
is_active=True, order__lt=target.order
)
other_target = other_target.latest("order")
except SocialAuthProvider.DoesNotExist:
other_target = None
if other_target:
other_target.order, target.order = target.order, other_target.order
other_target.save(update_fields=["order"])
target.save(update_fields=["order"])
clear_socialauth_cache()
message = pgettext_lazy(
"admin social auth providers",
"Login with %(provider)s has been moved before %(other)s.",
)
targets_names = {"provider": target, "other": other_target}
messages.success(request, message % targets_names)
| 4,872
|
Python
|
.py
| 101
| 38.712871
| 88
| 0.66456
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,891
|
twitter.py
|
rafalp_Misago/misago/socialauth/admin/forms/twitter.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from .base import OAuthProviderForm
class TwitterForm(OAuthProviderForm):
key = forms.CharField(
label=pgettext_lazy("admin social auth twitter form", "Consumer API key"),
required=False,
)
secret = forms.CharField(
label=pgettext_lazy(
"admin social auth twitter form", "Consumer API secret key"
),
required=False,
)
| 465
|
Python
|
.py
| 14
| 27.142857
| 82
| 0.696429
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,892
|
github.py
|
rafalp_Misago/misago/socialauth/admin/forms/github.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from .base import OAuthProviderForm
class GitHubForm(OAuthProviderForm):
key = forms.CharField(
label=pgettext_lazy("admin social auth github form", "Client ID"),
required=False,
)
secret = forms.CharField(
label=pgettext_lazy("admin social auth github form", "Client Secret"),
required=False,
)
| 423
|
Python
|
.py
| 12
| 30
| 78
| 0.723039
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,893
|
facebook.py
|
rafalp_Misago/misago/socialauth/admin/forms/facebook.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from .base import OAuthProviderForm
class FacebookForm(OAuthProviderForm):
key = forms.CharField(
label=pgettext_lazy("admin social auth facebook form", "App ID"),
required=False,
)
secret = forms.CharField(
label=pgettext_lazy("admin social auth facebook form", "App Secret"),
required=False,
)
| 423
|
Python
|
.py
| 12
| 30
| 77
| 0.723039
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,894
|
__init__.py
|
rafalp_Misago/misago/socialauth/admin/forms/__init__.py
|
from .base import OAuthProviderForm, ProviderForm
from .discord import DiscordForm
from .facebook import FacebookForm
from .github import GitHubForm
from .google import GoogleForm
from .twitter import TwitterForm
| 213
|
Python
|
.py
| 6
| 34.5
| 49
| 0.874396
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,895
|
google.py
|
rafalp_Misago/misago/socialauth/admin/forms/google.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from .base import OAuthProviderForm
class GoogleForm(OAuthProviderForm):
key = forms.CharField(
label=pgettext_lazy("admin social auth google form", "Client ID"),
required=False,
)
secret = forms.CharField(
label=pgettext_lazy("admin social auth google form", "Client Secret"),
required=False,
)
| 423
|
Python
|
.py
| 12
| 30
| 78
| 0.723039
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,896
|
base.py
|
rafalp_Misago/misago/socialauth/admin/forms/base.py
|
from django import forms
from django.utils.translation import gettext, pgettext_lazy
from ....admin.forms import ColorField, YesNoSwitch
from ...models import SocialAuthProvider
from ..ordering import get_next_free_order
class ProviderForm(forms.ModelForm):
button_text = forms.CharField(
label=pgettext_lazy("admin social auth provider form", "Button text"),
required=False,
)
button_color = ColorField(
label=pgettext_lazy("admin social auth provider form", "Button color"),
required=False,
)
is_active = YesNoSwitch(
label=pgettext_lazy("admin social auth provider form", "Enable this provider")
)
class Meta:
model = SocialAuthProvider
fields = ["button_text", "button_color", "is_active"]
def __init__(self, *args, **kwargs):
self.request = kwargs.pop("request")
super().__init__(*args, **kwargs)
def save(self):
settings = {}
for setting, value in self.cleaned_data.items():
if setting not in ["button_text", "button_color", "is_active"]:
settings[setting] = value
self.instance.settings = settings
if "is_active" in self.changed_data and self.cleaned_data.get("is_active"):
self.instance.order = get_next_free_order()
self.instance.save()
class OAuthProviderForm(ProviderForm):
associate_by_email = YesNoSwitch(
label=pgettext_lazy(
"admin social auth provider form", "Associate existing users by email"
),
help_text=pgettext_lazy(
"admin social auth provider form",
"This setting controls handling of e-mail collisions that occur when e-mail address returned from social site is already stored in the forum's database. Enabling this option will result in the user being signed in to pre-existing account. Otherwise they will be asked to specify a different e-mail to complete the sign in using social site.",
),
)
def clean(self):
cleaned_data = super().clean()
if cleaned_data.get("is_active"):
if not cleaned_data.get("key"):
self.add_error("key", gettext("This field is required."))
if not cleaned_data.get("secret"):
self.add_error("secret", gettext("This field is required."))
return cleaned_data
| 2,371
|
Python
|
.py
| 50
| 39.2
| 354
| 0.659879
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,897
|
discord.py
|
rafalp_Misago/misago/socialauth/admin/forms/discord.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from .base import OAuthProviderForm
class DiscordForm(OAuthProviderForm):
key = forms.CharField(
label=pgettext_lazy("admin social auth discord form", "App ID"),
required=False,
)
secret = forms.CharField(
label=pgettext_lazy("admin social auth discord form", "App Secret"),
required=False,
)
| 420
|
Python
|
.py
| 12
| 29.75
| 76
| 0.720988
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,898
|
conftest.py
|
rafalp_Misago/misago/socialauth/admin/tests/conftest.py
|
import pytest
from ...models import SocialAuthProvider
@pytest.fixture
def provider(db):
return SocialAuthProvider.objects.create(
provider="facebook", is_active=True, order=0
)
@pytest.fixture
def other_provider(db):
return SocialAuthProvider.objects.create(provider="github", is_active=True, order=1)
@pytest.fixture
def disabled_provider(db):
return SocialAuthProvider.objects.create(
provider="google-oauth2", is_active=False, order=0
)
| 484
|
Python
|
.py
| 15
| 28.4
| 88
| 0.764069
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
17,899
|
test_providers_list.py
|
rafalp_Misago/misago/socialauth/admin/tests/test_providers_list.py
|
from django.urls import reverse
admin_link = reverse("misago:admin:settings:socialauth:index")
def test_providers_list_renders(admin_client):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_providers_list_renders_with_active_provider(admin_client, provider):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_providers_list_renders_with_disabled_provider(admin_client, disabled_provider):
response = admin_client.get(admin_link)
assert response.status_code == 200
| 566
|
Python
|
.py
| 11
| 47.545455
| 88
| 0.780622
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|