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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
18,300
|
operations.py
|
rafalp_Misago/misago/cache/operations.py
|
from django.db.migrations import RunPython
class StartCacheVersioning(RunPython):
def __init__(self, cache):
code = start_cache_versioning(cache)
reverse_code = stop_cache_versioning(cache)
super().__init__(code, reverse_code)
class StopCacheVersioning(RunPython):
def __init__(self, cache):
code = stop_cache_versioning(cache)
reverse_code = start_cache_versioning(cache)
super().__init__(code, reverse_code)
def start_cache_versioning(cache):
def migration_operation(apps, _):
CacheVersion = apps.get_model("misago_cache", "CacheVersion")
CacheVersion.objects.create(cache=cache)
return migration_operation
def stop_cache_versioning(cache):
def migration_operation(apps, _):
CacheVersion = apps.get_model("misago_cache", "CacheVersion")
CacheVersion.objects.filter(cache=cache).delete()
return migration_operation
| 930
|
Python
|
.py
| 21
| 37.857143
| 69
| 0.70634
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,301
|
0003_categories.py
|
rafalp_Misago/misago/cache/migrations/0003_categories.py
|
# Generated by Django 4.2.10 on 2024-06-17 17:06
from django.db import migrations
from ..enums import CacheName
from ..operations import StartCacheVersioning
class Migration(migrations.Migration):
dependencies = [
("misago_cache", "0002_new_permissions"),
]
operations = [
StartCacheVersioning(CacheName.CATEGORIES),
]
| 356
|
Python
|
.py
| 11
| 28
| 51
| 0.735294
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,302
|
0002_new_permissions.py
|
rafalp_Misago/misago/cache/migrations/0002_new_permissions.py
|
# Generated by Django 4.2.8 on 2023-12-28 14:45
from django.db import migrations
from ..enums import CacheName
from ..operations import StartCacheVersioning
class Migration(migrations.Migration):
dependencies = [
("misago_cache", "0001_initial"),
]
operations = [
StartCacheVersioning(CacheName.GROUPS),
StartCacheVersioning(CacheName.MODERATORS),
StartCacheVersioning(CacheName.PERMISSIONS),
]
| 448
|
Python
|
.py
| 13
| 29.384615
| 52
| 0.737209
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,303
|
0001_initial.py
|
rafalp_Misago/misago/cache/migrations/0001_initial.py
|
# Generated by Django 1.11.16 on 2018-11-25 15:15
from django.db import migrations, models
from .. import utils
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="CacheVersion",
fields=[
(
"cache",
models.CharField(max_length=128, primary_key=True, serialize=False),
),
(
"version",
models.CharField(
default=utils.generate_version_string, max_length=8
),
),
],
)
]
| 693
|
Python
|
.py
| 23
| 17.782609
| 88
| 0.479699
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,304
|
conftest.py
|
rafalp_Misago/misago/cache/tests/conftest.py
|
import pytest
from ..models import CacheVersion
@pytest.fixture
def cache_version(db):
return CacheVersion.objects.create(cache="test_cache")
| 149
|
Python
|
.py
| 5
| 27.4
| 58
| 0.815603
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,305
|
test_invalidate_caches_management_command.py
|
rafalp_Misago/misago/cache/tests/test_invalidate_caches_management_command.py
|
from unittest.mock import Mock
from django.core.management import call_command
def test_management_command_invalidates_all_caches(mocker):
invalidate_all_caches = mocker.patch("misago.cache.versions.invalidate_all_caches")
call_command("invalidateversionedcaches", stdout=Mock())
invalidate_all_caches.assert_called_once()
| 338
|
Python
|
.py
| 6
| 52.833333
| 87
| 0.808511
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,306
|
test_assert_invalidates_cache.py
|
rafalp_Misago/misago/cache/tests/test_assert_invalidates_cache.py
|
import pytest
from ..models import CacheVersion
from ..test import assert_invalidates_cache
from ..versions import invalidate_cache
def test_assertion_fails_if_specified_cache_is_not_invaldiated(cache_version):
with pytest.raises(AssertionError):
with assert_invalidates_cache(cache_version.cache):
pass
def test_assertion_passess_if_specified_cache_is_invalidated(cache_version):
with assert_invalidates_cache(cache_version.cache):
invalidate_cache(cache_version.cache)
def test_assertion_fails_if_other_cache_is_invalidated(cache_version):
CacheVersion.objects.create(cache="changed_test")
with pytest.raises(AssertionError):
with assert_invalidates_cache(cache_version.cache):
invalidate_cache("changed_test")
| 784
|
Python
|
.py
| 16
| 43.5625
| 78
| 0.772668
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,307
|
test_cache_versions_middleware.py
|
rafalp_Misago/misago/cache/tests/test_cache_versions_middleware.py
|
from unittest.mock import Mock
import pytest
from ..middleware import cache_versions_middleware
@pytest.fixture
def get_response():
return Mock()
@pytest.fixture
def request_mock():
return Mock()
def test_middleware_sets_attr_on_request(db, get_response, request_mock):
middleware = cache_versions_middleware(get_response)
middleware(request_mock)
assert request_mock.cache_versions
def test_middleware_calls_get_response(db, get_response, request_mock):
middleware = cache_versions_middleware(get_response)
middleware(request_mock)
get_response.assert_called_once()
| 609
|
Python
|
.py
| 17
| 32.352941
| 73
| 0.785223
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,308
|
test_invalidating_caches.py
|
rafalp_Misago/misago/cache/tests/test_invalidating_caches.py
|
from ..models import CacheVersion
from ..versions import invalidate_all_caches, invalidate_cache
def test_invalidating_cache_updates_cache_version_in_database(cache_version):
invalidate_cache(cache_version.cache)
updated_cache_version = CacheVersion.objects.get(cache=cache_version.cache)
assert cache_version.version != updated_cache_version.version
def test_invalidating_all_caches_updates_cache_version_in_database(cache_version):
invalidate_all_caches()
updated_cache_version = CacheVersion.objects.get(cache=cache_version.cache)
assert cache_version.version != updated_cache_version.version
| 624
|
Python
|
.py
| 10
| 58.6
| 82
| 0.808197
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,309
|
invalidateversionedcaches.py
|
rafalp_Misago/misago/cache/management/commands/invalidateversionedcaches.py
|
from django.core.management.base import BaseCommand
from ...versions import invalidate_all_caches
class Command(BaseCommand):
help = "Invalidates versioned caches"
def handle(self, *args, **options):
invalidate_all_caches()
self.stdout.write("Invalidated all versioned caches.")
| 307
|
Python
|
.py
| 7
| 38.857143
| 62
| 0.75
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,310
|
test.py
|
rafalp_Misago/misago/graphql/test.py
|
import json
class GraphQLTestClient:
def __init__(self, client, url):
self.client = client
self.url = url
def query(self, query, variables=None):
data = {"query": query}
if variables:
data["variables"] = variables
response = self.client.post(
self.url, json.dumps(data), content_type="application/json"
)
json_data = response.json()
assert not json_data.get("errors"), json_data.get("errors")
return json_data["data"]
| 525
|
Python
|
.py
| 15
| 26.866667
| 71
| 0.599606
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,311
|
apps.py
|
rafalp_Misago/misago/graphql/apps.py
|
from django.apps import AppConfig
class MisagoGraphQLConfig(AppConfig):
name = "misago.graphql"
label = "misago_graphql"
verbose_name = "Misago GraphQL"
| 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)
|
18,312
|
conftest.py
|
rafalp_Misago/misago/graphql/admin/conftest.py
|
import pytest
from django.urls import reverse
@pytest.fixture
def admin_graphql_link():
return reverse("misago:admin:graphql:index")
| 139
|
Python
|
.py
| 5
| 25.6
| 48
| 0.810606
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,313
|
versioncheck.py
|
rafalp_Misago/misago/graphql/admin/versioncheck.py
|
import requests
from ariadne import QueryType
from django.core.cache import cache
from django.utils.translation import pgettext
from requests.exceptions import RequestException
from ... import __released__, __version__
from .status import Status
CACHE_KEY = "misago_admin_version_check"
CACHE_LENGTH = 3600 * 4 # 4 hours
version_check = QueryType()
@version_check.field("version")
def resolve_version(*_):
if not __released__:
return get_unreleased_error()
return check_version_with_api()
def get_unreleased_error():
return {
"status": Status.ERROR,
"message": pgettext(
"admin version check",
"The site is running using unreleased version of Misago.",
),
"description": pgettext(
"admin version check",
"Unreleased versions of Misago can contain serious breaking bugs or miss security features. They are also unsupported and it may be impossible to upgrade them to released version later.",
),
}
def check_version_with_api():
try:
latest_version = get_latest_version()
return compare_versions(__version__, latest_version)
except (RequestException, KeyError, ValueError):
return {
"status": Status.WARNING,
"message": pgettext(
"admin version check",
"Failed to connect to pypi.org API. Try again later.",
),
"description": pgettext(
"admin version check",
"Version check feature relies on the API operated by the Python Package Index (pypi.org) to retrieve the latest Misago release version.",
),
}
def get_latest_version():
data = cache.get(CACHE_KEY)
if not data:
data = get_latest_version_from_api()
cache.set(CACHE_KEY, data, CACHE_LENGTH)
return data
def get_latest_version_from_api():
api_url = "https://pypi.org/pypi/Misago/json"
r = requests.get(api_url)
r.raise_for_status()
return r.json()["info"]["version"]
def compare_versions(current, latest):
if latest == current:
return {
"status": Status.SUCCESS,
"message": pgettext(
"admin version check", "The site is running updated version of Misago."
),
"description": pgettext(
"admin version check", "Misago %(version)s is latest release."
)
% {"version": current},
}
return {
"status": Status.ERROR,
"message": pgettext(
"admin version check", "The site is running outdated version of Misago."
),
"description": pgettext(
"admin version check",
"The site is running Misago version %(version)s while version %(latest)s is available.",
)
% {"version": current, "latest": latest},
}
| 2,895
|
Python
|
.py
| 77
| 29.415584
| 199
| 0.621207
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,314
|
status.py
|
rafalp_Misago/misago/graphql/admin/status.py
|
from enum import IntEnum
from ariadne import EnumType
class Status(IntEnum):
ERROR = 0
WARNING = 1
SUCCESS = 2
status = EnumType("Status", Status)
| 164
|
Python
|
.py
| 7
| 20
| 35
| 0.736842
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,315
|
analytics.py
|
rafalp_Misago/misago/graphql/admin/analytics.py
|
from datetime import timedelta
from ariadne import QueryType
from django.contrib.auth import get_user_model
from django.core.cache import cache
from django.utils import timezone
from ...threads.models import Attachment, Post, Thread
from ...users.models import DataDownload, DeletedUser
CACHE_KEY = "misago_admin_analytics"
CACHE_LENGTH = 3600 * 4 # 4 hours
User = get_user_model()
analytics = QueryType()
@analytics.field("analytics")
def resolve_analytics(_, info, *, span):
span = clean_span(span)
cache_key = "%s_%s" % (CACHE_KEY, span)
data = cache.get(cache_key)
if not data:
data = get_data_from_db(span)
cache.set(cache_key, data, CACHE_LENGTH)
return data
def clean_span(span):
if span > 360:
return 360
if span < 30:
return 30
return span
def get_data_from_db(span):
analytics = Analytics(span)
return {
"users": analytics.get_data_for_model(User, "joined_on"),
"userDeletions": analytics.get_data_for_model(DeletedUser, "deleted_on"),
"threads": analytics.get_data_for_model(Thread, "started_on"),
"posts": analytics.get_data_for_model(Post, "posted_on"),
"attachments": analytics.get_data_for_model(Attachment, "uploaded_on"),
"dataDownloads": analytics.get_data_for_model(DataDownload, "requested_on"),
}
class Analytics:
def __init__(self, span):
self.today = timezone.now()
self.span = span
self.cutoff = self.today - timedelta(days=span * 2)
self.legend = self.get_legend()
def get_legend(self):
legend = []
for day in range(self.span * 2):
date = self.today - timedelta(days=day)
legend.append(date.strftime("%x"))
return legend
def get_empty_data(self):
return {k: 0 for k in self.legend}
def get_data_for_model(self, model, date_attr):
filter_kwarg = {"%s__gte" % date_attr: self.cutoff}
queryset = model.objects.filter(**filter_kwarg).order_by("-pk")
data = self.get_empty_data()
for item in queryset.values(date_attr).iterator(chunk_size=200):
date = item[date_attr].strftime("%x")
if date in data:
data[date] += 1
values = list(data.values())
current = list(reversed(values[: self.span]))
previous = list(reversed(values[self.span :]))
return {
"current": current,
"currentCumulative": cumulate_data(current),
"previous": previous,
"previousCumulative": cumulate_data(previous),
}
def cumulate_data(data_series):
data = []
for v in data_series:
if not data:
data.append(v)
else:
data.append(data[-1] + v)
return data
| 2,802
|
Python
|
.py
| 75
| 30.2
| 84
| 0.631054
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,316
|
__init__.py
|
rafalp_Misago/misago/graphql/admin/__init__.py
|
from ariadne_django.views import GraphQLView
from django.urls import path
from .schema import schema
class MisagoAdminExtension:
def register_urlpatterns(self, urlpatterns):
# GraphQL API
urlpatterns.namespace("graphql/", "graphql")
urlpatterns.patterns(
"graphql", path("", GraphQLView.as_view(schema=schema), name="index")
)
| 378
|
Python
|
.py
| 10
| 31.7
| 81
| 0.709589
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,317
|
schema.py
|
rafalp_Misago/misago/graphql/admin/schema.py
|
import os
from ariadne import QueryType, load_schema_from_path, make_executable_schema
from .analytics import analytics
from .status import status
from .versioncheck import version_check
FILE_PATH = os.path.dirname(os.path.abspath(__file__))
SCHEMA_PATH = os.path.join(FILE_PATH, "schema.graphql")
type_defs = load_schema_from_path(SCHEMA_PATH)
schema = make_executable_schema(type_defs, [analytics, status, version_check])
| 428
|
Python
|
.py
| 9
| 46.111111
| 78
| 0.8
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,318
|
conftest.py
|
rafalp_Misago/misago/graphql/admin/tests/conftest.py
|
import pytest
from django.urls import reverse
from ...test import GraphQLTestClient
@pytest.fixture
def admin_graphql_client(admin_client):
return GraphQLTestClient(admin_client, reverse("misago:admin:graphql:index"))
| 225
|
Python
|
.py
| 6
| 35.333333
| 81
| 0.828704
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,319
|
test_analytics.py
|
rafalp_Misago/misago/graphql/admin/tests/test_analytics.py
|
from datetime import timedelta
import pytest
from ariadne import gql
from django.utils import timezone
from ....threads.models import Attachment, AttachmentType
from ....threads.test import post_thread
from ....users.datadownloads import request_user_data_download
from ....users.deletesrecord import record_user_deleted_by_self
from ....users.test import create_test_user
from ..analytics import cumulate_data
test_query = gql(
"""
query getAnalytics($span: Int!) {
analytics(span: $span) {
users {
...data
}
userDeletions {
...data
}
threads {
...data
}
posts {
...data
}
attachments {
...data
}
dataDownloads {
...data
}
}
}
fragment data on AnalyticsData {
current
currentCumulative
previous
previousCumulative
}
"""
)
previous_datetime = timezone.now() - timedelta(days=30)
excluded_datetime = timezone.now() - timedelta(days=60)
def test_query_without_data_executes_without_errors(admin_graphql_client):
result = admin_graphql_client.query(test_query, {"span": 30})
assert result["analytics"]
def test_all_analytics_are_limited_to_requested_span(admin_graphql_client):
result = admin_graphql_client.query(test_query, {"span": 30})
for model_analytics in result["analytics"].values():
assert len(model_analytics["current"]) == 30
assert len(model_analytics["currentCumulative"]) == 30
assert len(model_analytics["previous"]) == 30
assert len(model_analytics["previousCumulative"]) == 30
def test_large_analytics_span_is_reduced_to_360(admin_graphql_client):
result = admin_graphql_client.query(test_query, {"span": 3000})
for model_analytics in result["analytics"].values():
assert len(model_analytics["current"]) == 360
assert len(model_analytics["currentCumulative"]) == 360
assert len(model_analytics["previous"]) == 360
assert len(model_analytics["previousCumulative"]) == 360
def test_short_analytics_span_is_extended_to_30(admin_graphql_client):
result = admin_graphql_client.query(test_query, {"span": 0})
for model_analytics in result["analytics"].values():
assert len(model_analytics["current"]) == 30
assert len(model_analytics["currentCumulative"]) == 30
assert len(model_analytics["previous"]) == 30
assert len(model_analytics["previousCumulative"]) == 30
def test_recent_user_registration_appears_in_current_analytics(admin_graphql_client):
create_test_user("User", "user@example.com")
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["users"]
assert sum(analytics["current"]) == 2 # includes admin
assert sum(analytics["previous"]) == 0
def test_older_user_registration_appears_in_previous_analytics(admin_graphql_client):
create_test_user("User", "user@example.com", joined_on=previous_datetime)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["users"]
assert sum(analytics["current"]) == 1 # includes admin
assert sum(analytics["previous"]) == 1
def test_old_user_registration_is_excluded_from_analytics(admin_graphql_client):
create_test_user("User", "user@example.com", joined_on=excluded_datetime)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["users"]
assert sum(analytics["current"]) == 1 # includes admin
assert sum(analytics["previous"]) == 0
def test_recent_thread_appears_in_current_analytics(
admin_graphql_client, default_category
):
post_thread(default_category)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["threads"]
assert sum(analytics["current"]) == 1
assert sum(analytics["previous"]) == 0
def test_older_thread_appears_in_previous_analytics(
admin_graphql_client, default_category
):
post_thread(default_category, started_on=previous_datetime)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["threads"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 1
def test_old_thread_is_excluded_from_analytics(admin_graphql_client, default_category):
post_thread(default_category, started_on=excluded_datetime)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["threads"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 0
def test_recent_post_appears_in_current_analytics(
admin_graphql_client, default_category
):
post_thread(default_category)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["posts"]
assert sum(analytics["current"]) == 1
assert sum(analytics["previous"]) == 0
def test_older_post_appears_in_previous_analytics(
admin_graphql_client, default_category
):
post_thread(default_category, started_on=previous_datetime)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["posts"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 1
def test_old_post_is_excluded_from_analytics(admin_graphql_client, default_category):
post_thread(default_category, started_on=excluded_datetime)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["posts"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 0
@pytest.fixture
def attachment_type(db):
return AttachmentType.objects.create(name="test", extensions="test")
def test_recent_attachment_appears_in_current_analytics(
admin_graphql_client, attachment_type
):
Attachment.objects.create(
filetype=attachment_type,
uploader_name="test",
uploader_slug="test",
filename="test",
)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["attachments"]
assert sum(analytics["current"]) == 1
assert sum(analytics["previous"]) == 0
def test_older_attachment_appears_in_previous_analytics(
admin_graphql_client, attachment_type
):
Attachment.objects.create(
filetype=attachment_type,
uploader_name="test",
uploader_slug="test",
filename="test",
uploaded_on=previous_datetime,
)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["attachments"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 1
def test_old_attachment_is_excluded_from_analytics(
admin_graphql_client, attachment_type
):
Attachment.objects.create(
filetype=attachment_type,
uploader_name="test",
uploader_slug="test",
filename="test",
uploaded_on=excluded_datetime,
)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["attachments"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 0
def test_recent_data_download_appears_in_current_analytics(admin_graphql_client, user):
request_user_data_download(user)
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["dataDownloads"]
assert sum(analytics["current"]) == 1
assert sum(analytics["previous"]) == 0
def test_older_data_download_appears_in_previous_analytics(admin_graphql_client, user):
download = request_user_data_download(user)
download.requested_on = previous_datetime
download.save()
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["dataDownloads"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 1
def test_old_data_download_is_excluded_from_analytics(admin_graphql_client, user):
download = request_user_data_download(user)
download.requested_on = excluded_datetime
download.save()
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["dataDownloads"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 0
def test_recent_user_deletion_appears_in_current_analytics(admin_graphql_client):
record_user_deleted_by_self()
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["userDeletions"]
assert sum(analytics["current"]) == 1
assert sum(analytics["previous"]) == 0
def test_older_user_deletion_appears_in_previous_analytics(admin_graphql_client):
deletion = record_user_deleted_by_self()
deletion.deleted_on = previous_datetime
deletion.save()
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["userDeletions"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 1
def test_old_user_deletion_is_excluded_from_analytics(admin_graphql_client):
deletion = record_user_deleted_by_self()
deletion.deleted_on = excluded_datetime
deletion.save()
result = admin_graphql_client.query(test_query, {"span": 30})
analytics = result["analytics"]["userDeletions"]
assert sum(analytics["current"]) == 0
assert sum(analytics["previous"]) == 0
def test_data_is_cumulated():
assert cumulate_data([1, 2]) == [1, 3]
| 9,841
|
Python
|
.py
| 220
| 38.427273
| 87
| 0.682674
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,320
|
test_version_check.py
|
rafalp_Misago/misago/graphql/admin/tests/test_version_check.py
|
from unittest.mock import ANY, Mock
import pytest
from ariadne import gql
from requests.exceptions import RequestException
from .... import __version__
from ..versioncheck import CACHE_KEY, CACHE_LENGTH, get_latest_version, resolve_version
test_query = gql("{ version { status message description } }")
def mock_requests_get(mocker, mock):
return mocker.patch("requests.get", return_value=Mock(json=mock))
def test_version_check_query_returns_error_if_misago_version_is_unreleased(
admin_graphql_client, mocker
):
mocker.patch("misago.graphql.admin.versioncheck.__released__", False)
mock_requests_get(mocker, Mock(return_value={"info": {"version": "outdated"}}))
result = admin_graphql_client.query(test_query)
assert result["version"]["status"] == "ERROR"
def test_version_check_query_returns_success_if_site_is_updated(
admin_graphql_client, mocker
):
mocker.patch("misago.graphql.admin.versioncheck.__released__", True)
mock_requests_get(mocker, Mock(return_value={"info": {"version": __version__}}))
result = admin_graphql_client.query(test_query)
assert result["version"]["status"] == "SUCCESS"
def test_version_check_query_returns_error_if_site_is_outdated(
admin_graphql_client, mocker
):
mocker.patch("misago.graphql.admin.versioncheck.__released__", True)
mock_requests_get(mocker, Mock(return_value={"info": {"version": "outdated"}}))
result = admin_graphql_client.query(test_query)
assert result["version"]["status"] == "ERROR"
def test_version_check_query_returns_warning_if_version_check_failed(
admin_graphql_client, mocker
):
mocker.patch("misago.graphql.admin.versioncheck.__released__", True)
mock_requests_get(mocker, Mock(side_effect=RequestException()))
result = admin_graphql_client.query(test_query)
assert result["version"]["status"] == "WARNING"
def test_version_check_result_is_cached(mocker):
mocker.patch("misago.graphql.admin.versioncheck.__released__", True)
set_cache = mocker.patch("django.core.cache.cache.set")
mock_requests_get(mocker, Mock(return_value={"info": {"version": "outdated"}}))
resolve_version()
set_cache.assert_called_with(CACHE_KEY, ANY, CACHE_LENGTH)
def test_failed_version_check_result_is_not_cached(admin_graphql_client, mocker):
mocker.patch("misago.graphql.admin.versioncheck.__released__", True)
set_cache = mocker.patch("django.core.cache.cache.set")
mock_requests_get(mocker, Mock(side_effect=RequestException()))
resolve_version()
set_cache.assert_not_called()
def test_remote_api_is_not_called_if_version_check_cache_is_available(mocker):
mocker.patch("misago.graphql.admin.versioncheck.__released__", True)
mocker.patch("django.core.cache.cache.get", return_value={"status": "TEST"})
api_mock = mock_requests_get(mocker, Mock())
resolve_version()
api_mock.assert_not_called()
def test_version_check_cache_is_returned_when_set(mocker):
mocker.patch("misago.graphql.admin.versioncheck.__released__", True)
mocker.patch("django.core.cache.cache.get", return_value={"status": "TEST"})
mock_requests_get(mocker, Mock())
assert get_latest_version() == {"status": "TEST"}
| 3,208
|
Python
|
.py
| 60
| 49.45
| 87
| 0.732331
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,321
|
__init__.py
|
rafalp_Misago/misago/testutils/__init__.py
|
from .permissions import (
grant_category_group_permissions,
remove_category_group_permissions,
)
__all__ = [
"grant_category_group_permissions",
"remove_category_group_permissions",
]
| 202
|
Python
|
.py
| 8
| 22.125
| 40
| 0.735751
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,322
|
permissions.py
|
rafalp_Misago/misago/testutils/permissions.py
|
from ..categories.models import Category
from ..permissions.enums import CategoryPermission
from ..permissions.models import CategoryGroupPermission
from ..users.models import Group
def grant_category_group_permissions(
category: Category, user_group: Group, *permissions: CategoryPermission
):
CategoryGroupPermission.objects.bulk_create(
[
CategoryGroupPermission(
category=category, group=user_group, permission=permission
)
for permission in permissions
]
)
def remove_category_group_permissions(category: Category, user_group: Group):
CategoryGroupPermission.objects.filter(category=category, group=user_group).delete()
| 713
|
Python
|
.py
| 17
| 35.764706
| 88
| 0.75
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,323
|
models.py
|
rafalp_Misago/misago/plugins/models.py
|
from typing import Any
from django.contrib.postgres.indexes import GinIndex
from django.db import models
class PluginDataModel(models.Model):
plugin_data = models.JSONField(default=dict)
class Meta:
abstract = True
indexes = [GinIndex(fields=["plugin_data"])]
| 288
|
Python
|
.py
| 8
| 31.5
| 52
| 0.753623
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,324
|
manifest.py
|
rafalp_Misago/misago/plugins/manifest.py
|
from dataclasses import dataclass
from typing import Optional
@dataclass(frozen=True)
class MisagoPlugin:
"""
A frozen dataclass with plugin's metadata.
# Optional arguments
## `name: str`
A string with the plugin name. Limited to 100 characters.
## `description: str`
A string with the plugin description. Limited to 250 characters.
## `license: str`
A string with the plugin license. Limited to 50 characters.
## `icon: str`
A string with the plugin icon. Must be a valid Font Awesome icon CSS name,
e.g., `fa fa-icon` or `fas fa-other-icon`.
## `color: str`
A string with the plugin icon's color. Must be a color hex format prefixed
with `#`, e.g., `#efefef`.
## `version: str`
A string with the plugin version. Limited to 50 characters.
## `author: str`
A string with the plugin author's name. Limited to 150 characters.
## `homepage: str`
A string with the URL to the plugin's homepage.
## `sponsor: str`
A string with the URL to a page with sponsorship instructions or a donation form.
## `help: str`
A string with the URL to the plugin's help page or a support forum.
## `bugs: str`
A string with the URL to the plugin's bug reporting tool.
## `repo: str`
A string with the URL to the plugin's code repository.
# Example
The code below shows a `misago_plugin.py` file with a plugin manifest with all
fields filled in:
```python
from misago import MisagoPlugin
manifest = MisagoPlugin(
name="Example plugin with complete manifest",
description="This plugin has all fields in its manifest filled in.",
license="GNU GPL v2",
icon="fa fa-wrench",
color="#9b59b6",
version="0.1DEV",
author="Rafał Pitoń",
homepage="https://misago-project.org",
sponsor="https://github.com/sponsors/rafalp",
help="https://misago-project.org/c/support/30/",
bugs="https://misago-project.org/c/bug-reports/29/",
repo="https://github.com/rafalp/misago",
)
```
"""
name: Optional[str] = None
description: Optional[str] = None
license: Optional[str] = None
icon: Optional[str] = None
color: Optional[str] = None
version: Optional[str] = None
author: Optional[str] = None
homepage: Optional[str] = None
sponsor: Optional[str] = None
help: Optional[str] = None
bugs: Optional[str] = None
repo: Optional[str] = None
| 2,523
|
Python
|
.py
| 66
| 32.212121
| 85
| 0.664327
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,325
|
urlpatterns.py
|
rafalp_Misago/misago/plugins/urlpatterns.py
|
from importlib.util import find_spec
from django.urls import URLResolver, include, path
def discover_plugins_urlpatterns(plugins: list[str]) -> list[URLResolver]:
urlpatterns: list[URLResolver] = []
for plugin in plugins:
if plugin_has_urls(plugin):
urlpatterns.append(path("", include(f"{plugin}.urls")))
return urlpatterns
def plugin_has_urls(plugin: str) -> bool:
return bool(find_spec(f"{plugin}.urls"))
| 450
|
Python
|
.py
| 10
| 39.8
| 74
| 0.714286
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,326
|
enums.py
|
rafalp_Misago/misago/plugins/enums.py
|
from enum import Enum
class PluginOutlet(Enum):
"""Enum with standard plugin outlets defined by Misago.
Members values are descriptions of outlets locations, used by the docs generator.
"""
TEST = "Used in some tests."
ADMIN_DASHBOARD_START = "On the Admin dashboard page, above all other content."
ADMIN_DASHBOARD_AFTER_CHECKS = "On the Admin dashboard page, below the Checks card."
ADMIN_DASHBOARD_AFTER_ANALYTICS = (
"On the Admin dashboard page, below the Analytics card."
)
ADMIN_DASHBOARD_END = "On the Admin dashboard page, below all other content."
LOGIN_PAGE_START = "On the Sign in page, above the form."
LOGIN_PAGE_END = "On the Sign in page, below the form."
CATEGORIES_LIST_START = "On the Categories page, above the list."
CATEGORIES_LIST_END = "On the Categories page, below the list."
THREADS_LIST_START = "On the Threads page, above the list."
THREADS_LIST_MIDDLE = "On the Threads page, between the subcategories and the list."
THREADS_LIST_END = "On the Threads page, below the list."
CATEGORY_THREADS_LIST_START = "On the Category threads page, above the list."
CATEGORY_THREADS_LIST_MIDDLE = (
"On the Category threads page, between the subcategories and the list."
)
CATEGORY_THREADS_LIST_END = "On the Category threads page, below the list."
PRIVATE_THREADS_LIST_START = "On the Private threads page, above the list."
PRIVATE_THREADS_LIST_END = "On the Private threads page, below the list."
THREADS_LIST_TOOLBAR_START = "On threads lists pages, at the start of the toolbar."
THREADS_LIST_TOOLBAR_BEFORE_SPACER = (
"On threads lists pages, before the toolbar's spacer."
)
THREADS_LIST_TOOLBAR_AFTER_SPACER = (
"On threads lists pages, after the toolbar's spacer."
)
THREADS_LIST_TOOLBAR_END = "On threads lists pages, at the end of the toolbar."
THREAD_REPLIES_PAGE_START = "On the Thread replies page, below the page's header."
THREAD_REPLIES_PAGE_END = (
"On the Thread replies page, above the bottom breadcrumbs."
)
THREAD_REPLIES_PAGE_TOOLBAR_START = (
"On the Thread replies page, at the start of the toolbar."
)
THREAD_REPLIES_PAGE_TOOLBAR_BEFORE_SPACER = (
"On the Thread replies page, before the toolbar's spacer."
)
THREAD_REPLIES_PAGE_TOOLBAR_AFTER_SPACER = (
"On the Thread replies page, after the toolbar's spacer."
)
THREAD_REPLIES_PAGE_TOOLBAR_END = (
"On the Thread replies page, at the end of the toolbar."
)
PRIVATE_THREAD_REPLIES_PAGE_START = (
"On the Private thread replies page, below the page's header."
)
PRIVATE_THREAD_REPLIES_PAGE_END = (
"On the Private thread replies page, above the bottom breadcrumbs."
)
PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_START = (
"On the Private thread replies page, at the start of the toolbar."
)
PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_BEFORE_SPACER = (
"On the Private thread replies page, before the toolbar's spacer."
)
PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_AFTER_SPACER = (
"On the Private thread replies page, after the toolbar's spacer."
)
PRIVATE_THREAD_REPLIES_PAGE_TOOLBAR_END = (
"On the Private thread replies page, at the end of the toolbar."
)
| 3,366
|
Python
|
.py
| 68
| 43.514706
| 88
| 0.696924
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,327
|
discover.py
|
rafalp_Misago/misago/plugins/discover.py
|
import importlib
import re
import sys
from pathlib import Path
from typing import Dict, List
def discover_plugins(plugins_path: str | None) -> List[str]:
if not plugins_path:
return []
plugins_path_obj = Path(plugins_path)
if not plugins_path_obj.is_dir():
return []
plugins_apps = discover_plugins_in_directory(plugins_path_obj)
pip_install = plugins_path_obj / "pip-install.txt"
if pip_install.is_file():
plugins_apps += discover_plugins_in_pip_install(pip_install)
return sorted(plugins_apps)
def discover_plugins_in_directory(plugins_path: Path) -> List[str]:
plugins_apps: List[str] = []
plugins_paths: Dict[str, str] = {}
# First step: glob plugin Python packages
for plugin_path in sorted(plugins_path.glob("*/*/misago_plugin.py")):
plugin_package = plugin_path.parent
# Skip plugins that are not valid Python packages
plugin_package_init = plugin_package / "__init__.py"
if not plugin_package_init.is_file():
continue
# Add plugin package name to Django apps for later import
plugins_apps.append(plugin_package.name)
# Store plugin path for later adding to sys.path
plugins_paths[plugin_package.name] = str(plugin_package.parent)
plugins_apps = sorted(plugins_apps)
# Add unique plugins paths to Python path ordered by app name
for plugin_app in plugins_apps:
plugin_path = plugins_paths[plugin_app]
if plugin_path not in sys.path:
sys.path.append(plugin_path)
return plugins_apps
def discover_plugins_in_pip_install(pip_install_path: Path) -> List[str]:
pip_install_lines = read_pip_install_file(pip_install_path)
return validate_modules_from_pip_install(pip_install_lines)
PIP_LINE_RE = re.compile(r"^[a-z0-9-_]+")
def read_pip_install_file(pip_install_path: Path) -> List[str]:
clean_lines: List[str] = []
with open(pip_install_path, "r") as fp:
file_lines: List[str] = fp.readlines()
for file_line in file_lines:
clean_line = file_line.strip()
if clean_line.startswith("#"):
continue
if "#" in clean_line:
comment_start = clean_line.find("#")
clean_line = clean_line[:comment_start].strip()
clean_line_match = PIP_LINE_RE.match(clean_line)
if not clean_line_match:
continue
clean_line = clean_line_match.group(0).replace("-", "_")
if clean_line and clean_line not in clean_lines:
clean_lines.append(clean_line)
return clean_lines
def validate_modules_from_pip_install(pip_install_lines: List[str]) -> List[str]:
valid_lines: List[str] = []
for pip_install_line in pip_install_lines:
try:
module = importlib.import_module(pip_install_line)
module_path = Path(module.__file__).parent
if not module_path.is_dir():
continue
misago_plugin_path = module_path / "misago_plugin.py"
if not misago_plugin_path.is_file():
continue
valid_lines.append(pip_install_line)
except:
pass
return valid_lines
| 3,260
|
Python
|
.py
| 74
| 35.5
| 81
| 0.639759
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,328
|
outlets.py
|
rafalp_Misago/misago/plugins/outlets.py
|
from functools import wraps
from typing import Dict, List, Protocol
from django.http import HttpRequest
from django.template import Context
from django.utils.safestring import SafeString, mark_safe
from .enums import PluginOutlet
from .hooks import ActionHook
class PluginOutletHookAction(Protocol):
def __call__(
self, request: HttpRequest, context: dict | Context
) -> str | SafeString | None:
pass
class PluginOutletHook(ActionHook[PluginOutletHookAction]):
__slots__ = ActionHook.__slots__
def __call__(
self, request: HttpRequest, context: dict | Context
) -> List[str | SafeString | None]:
return super().__call__(request, context)
template_outlets: Dict[str, PluginOutletHook] = {}
def create_new_outlet(outlet_name: str):
if outlet_name in template_outlets:
raise ValueError(f"Template outlet '{outlet_name}' already exists.")
template_outlets[plugin_outlet.name] = PluginOutletHook()
for plugin_outlet in PluginOutlet:
create_new_outlet(plugin_outlet.name)
def append_outlet_action(
outlet_name: str | PluginOutlet, action: PluginOutletHookAction
):
get_outlet(outlet_name).append_action(action)
def prepend_outlet_action(
outlet_name: str | PluginOutlet, action: PluginOutletHookAction
):
get_outlet(outlet_name).prepend_action(action)
def get_outlet(outlet_name: str | PluginOutlet) -> PluginOutletHook:
try:
if isinstance(outlet_name, PluginOutlet):
return template_outlets[outlet_name.name]
return template_outlets[outlet_name]
except KeyError as exc:
raise KeyError(f"Unknown template outlet: {outlet_name}") from exc
def template_outlet_action(f):
"""Decorator for an outlet action that renders a template with returned context."""
@wraps(f)
@mark_safe
def wrapped_outlet_action(request: HttpRequest, context: Context):
template_data = f(request, context)
if template_data is None:
return ""
if isinstance(template_data, str):
return _include_template(template_data, context)
if isinstance(template_data, tuple):
template_name, new_context = template_data
return _include_template(template_name, context, new_context)
return ""
return wrapped_outlet_action
def _include_template(
template_name: str, context: Context, new_context: dict | None = None
):
"""Subset of Django include template tag.
Works only with Django template engine.
"""
cache = context.render_context.dicts[0].setdefault("_template_outlet_action", {})
template = cache.get(template_name)
if template is None:
template = context.template.engine.get_template(template_name)
cache[template_name] = template
if new_context:
with context.push(**new_context):
return template.render(context)
return template.render(context)
| 2,946
|
Python
|
.py
| 70
| 36.171429
| 87
| 0.713432
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,329
|
metadata.py
|
rafalp_Misago/misago/plugins/metadata.py
|
import re
from dataclasses import dataclass
from importlib import import_module
from pathlib import Path
from types import ModuleType
from typing import Dict, List, Optional
from urllib.parse import urlparse
from django.conf import settings
from django.utils.translation import pgettext_lazy
from .manifest import MisagoPlugin
@dataclass(frozen=True)
class PluginMetadataUrl:
url: str
netloc: str
@dataclass(frozen=True)
class PluginMetadata:
package: str
dirname: str
has_manifest: bool
manifest_error: Optional[str]
name: Optional[str]
description: Optional[str]
license: Optional[str]
icon: Optional[str]
color: Optional[str]
version: Optional[str]
author: Optional[str]
homepage: Optional[PluginMetadataUrl]
sponsor: Optional[PluginMetadataUrl]
help: Optional[PluginMetadataUrl]
bugs: Optional[PluginMetadataUrl]
repo: Optional[PluginMetadataUrl]
@property
def has_urls(self) -> bool:
return bool(
self.homepage or self.sponsor or self.help or self.bugs or self.repo
)
class PluginsMetadataLoader:
initialized: bool
plugins: List[str]
metadata: Dict[str, PluginMetadata]
def __init__(self, plugins: List[str]):
self.initialized = False
self.plugins = plugins
self.metadata = {}
def get_metadata(self) -> Dict[str, PluginMetadata]:
if not self.initialized:
self.metadata = self.build_metadata(self.plugins)
self.initialized = True
return self.metadata
def build_metadata(self, plugins: List[str]) -> Dict[str, PluginMetadata]:
metadata: Dict[str, PluginMetadata] = {}
for plugin_package in plugins:
metadata[plugin_package] = self.build_plugin_metadata(plugin_package)
return metadata
def build_plugin_metadata(self, plugin_package: str) -> PluginMetadata:
package_obj = import_module(plugin_package)
manifest: Optional[MisagoPlugin] = None
manifest_error: Optional[str] = None
try:
manifest_module = import_module(f"{plugin_package}.misago_plugin")
manifest_attr = getattr(manifest_module, "manifest", None)
if manifest_attr is not None and not isinstance(
manifest_attr, MisagoPlugin
):
raise TypeError(
pgettext_lazy(
"plugins metadata",
"Plugin manifest is of an unexpected type '%(manifest_type)s' (expected MisagoPlugin instance)",
)
% {"manifest_type": type(manifest_attr).__name__}
)
manifest = manifest_attr
except Exception as exc:
manifest_error = f"{type(exc).__name__}: {exc}"
return create_plugin_metadata(
plugin_package,
package_obj,
manifest,
manifest_error,
)
def create_plugin_metadata(
plugin_package: str,
package_obj: ModuleType,
manifest: Optional[MisagoPlugin],
manifest_error: Optional[str],
) -> PluginMetadata:
has_manifest = False
name: Optional[str] = None
description: Optional[str] = None
license: Optional[str] = None
icon: Optional[str] = None
color: Optional[str] = None
version: Optional[str] = None
author: Optional[str] = None
homepage: Optional[PluginMetadataUrl] = None
sponsor: Optional[PluginMetadataUrl] = None
help: Optional[PluginMetadataUrl] = None
bugs: Optional[PluginMetadataUrl] = None
repo: Optional[PluginMetadataUrl] = None
if manifest:
has_manifest = True
name = clean_plugin_str(manifest.name, 100)
description = clean_plugin_str(manifest.description, 250)
license = clean_plugin_str(manifest.license, 50)
icon = clean_plugin_icon(manifest.icon)
color = clean_plugin_color(manifest.color)
version = clean_plugin_str(manifest.version, 50)
author = clean_plugin_str(manifest.author, 150)
homepage = clean_plugin_url(manifest.homepage)
sponsor = clean_plugin_url(manifest.sponsor)
help = clean_plugin_url(manifest.help)
bugs = clean_plugin_url(manifest.bugs)
repo = clean_plugin_url(manifest.repo)
return PluginMetadata(
package=plugin_package,
dirname=Path(package_obj.__file__).parent.parent.name,
has_manifest=has_manifest,
manifest_error=manifest_error,
name=name,
description=description,
license=license,
icon=icon,
color=color,
version=version,
author=author,
homepage=homepage,
sponsor=sponsor,
help=help,
bugs=bugs,
repo=repo,
)
def clean_plugin_str(value: Optional[str], max_length: int) -> Optional[str]:
if isinstance(value, str):
return (value.strip()[:max_length].strip()) or None
return None
URL_RE = re.compile(r"^https?://[A-Za-z0-9-_/?=&#.]+$")
def clean_plugin_url(value: Optional[str]) -> Optional[PluginMetadataUrl]:
if isinstance(value, str) and URL_RE.match(value):
try:
url = urlparse(value)
if not url:
return None
return PluginMetadataUrl(
url=value,
netloc=url.netloc,
)
except ValueError:
return None
return None
ICON_RE = re.compile(r"^fa(r|s)? fa-[a-z-]+$")
def clean_plugin_icon(value: Optional[str]) -> Optional[str]:
if isinstance(value, str) and ICON_RE.match(value):
return value
return None
COLOR_RE = re.compile(r"^#[0-9a-f]{6}$", re.IGNORECASE)
def clean_plugin_color(value: Optional[str]) -> Optional[str]:
if isinstance(value, str) and COLOR_RE.match(value):
return value.upper()
return None
plugins_metadata = PluginsMetadataLoader(settings.INSTALLED_PLUGINS)
| 5,955
|
Python
|
.py
| 161
| 29.15528
| 120
| 0.651373
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,330
|
hooks.py
|
rafalp_Misago/misago/plugins/hooks.py
|
from functools import reduce
from typing import Any, Generic, List, TypeVar, cast
Action = TypeVar("Action")
Filter = TypeVar("Filter")
class ActionHook(Generic[Action]):
__slots__ = ("_actions_first", "_actions_last", "_cache")
_actions_first: List[Action]
_actions_last: List[Action]
_cache: List[Action] | None
def __init__(self):
self._actions_first = []
self._actions_last = []
self._cache = None
def __bool__(self) -> bool:
return bool(self._actions_first or self._actions_last)
def append_action(self, action: Action):
self._actions_last.append(action)
self.invalidate_cache()
def prepend_action(self, action: Action):
self._actions_first.insert(0, action)
self.invalidate_cache()
def invalidate_cache(self):
self._cache = None
def __call__(self, *args, **kwargs) -> List[Any]:
if self._cache is None:
self._cache = self._actions_first + self._actions_last
if not self._cache:
return []
return [action(*args, **kwargs) for action in self._cache]
class FilterHook(Generic[Action, Filter]):
__slots__ = ("_filters_first", "_filters_last", "_cache")
_filters_first: List[Filter]
_filters_last: List[Filter]
_cache: Action | None
def __init__(self):
self._filters_first = []
self._filters_last = []
self._cache = None
def __bool__(self) -> bool:
return bool(self._filters_first or self._filters_last)
def append_filter(self, filter_: Filter):
self._filters_last.append(filter_)
self.invalidate_cache()
def prepend_filter(self, filter_: Filter):
self._filters_first.insert(0, filter_)
self.invalidate_cache()
def invalidate_cache(self):
self._cache = None
def get_reduced_action(self, action: Action) -> Action:
def reduce_filter(action: Action, next_filter: Filter) -> Action:
def reduced_filter(*args, **kwargs):
return next_filter(action, *args, **kwargs)
return cast(Action, reduced_filter)
filters = self._filters_first + self._filters_last
return reduce(reduce_filter, filters, action)
def __call__(self, action: Action, *args, **kwargs):
if self._cache is None:
self._cache = self.get_reduced_action(action)
return self._cache(*args, **kwargs) # type: ignore
| 2,461
|
Python
|
.py
| 59
| 34.067797
| 73
| 0.622792
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,331
|
misago_plugins.py
|
rafalp_Misago/misago/plugins/templatetags/misago_plugins.py
|
from typing import List
from django import template
from django.utils.html import conditional_escape
from django.utils.safestring import mark_safe
from ..outlets import template_outlets
register = template.Library()
PLUGINOUTLET_SYNTAX_ERROR = 'pluginoutlet tag syntax is "pluginoutlet OUTLET_NAME"'
@register.tag()
def pluginoutlet(_, token):
split_contents = token.split_contents()
if len(split_contents) != 2:
raise template.TemplateSyntaxError(PLUGINOUTLET_SYNTAX_ERROR)
outlet_name = split_contents[1].strip()
if not outlet_name:
raise template.TemplateSyntaxError(PLUGINOUTLET_SYNTAX_ERROR)
return PluginOutletNode(outlet_name)
class PluginOutletNode(template.Node):
outlet_name: str
def __init__(self, outlet_name: str):
self.outlet_name = outlet_name
def render(self, context):
outlet = template_outlets.get(self.outlet_name)
if not outlet:
return ""
request = context.get("request")
outlet_html = ""
for plugin_html in outlet(request, context):
if plugin_html is not None:
outlet_html += conditional_escape(plugin_html)
return mark_safe(outlet_html)
HASPLUGINS_SYNTAX_ERROR = 'hasplugins tag syntax is "hasplugins OUTLET_NAME"'
@register.tag()
def hasplugins(parser, token):
split_contents = token.split_contents()
if len(split_contents) != 2:
raise template.TemplateSyntaxError(HASPLUGINS_SYNTAX_ERROR)
outlet_name = split_contents[1].strip()
if not outlet_name:
raise template.TemplateSyntaxError(HASPLUGINS_SYNTAX_ERROR)
nodelists: List[template.NodeList] = [parser.parse(("else", "endhasplugins"))]
token = parser.next_token()
if token.contents == "else":
nodelists.append(parser.parse(("endhasplugins",)))
token = parser.next_token()
if token.contents != "endhasplugins":
raise template.TemplateSyntaxError(
'Malformed template tag at line {}: "{}"'.format(
token.lineno, token.contents
)
)
return HasPluginsNode(outlet_name, nodelists)
class HasPluginsNode(template.Node):
outlet_name: str
nodelist: template.NodeList
nodelist_else: template.NodeList | None
def __init__(self, outlet_name: str, nodelists: List[template.NodeList]):
self.outlet_name = outlet_name
self.nodelist = nodelists[0]
try:
self.nodelist_else = nodelists[1]
except IndexError:
self.nodelist_else = None
def render(self, context):
outlet = template_outlets.get(self.outlet_name)
if not outlet:
if self.nodelist_else is not None:
return self.nodelist_else.render(context)
return ""
return self.nodelist.render(context)
| 2,842
|
Python
|
.py
| 69
| 33.855072
| 83
| 0.682945
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,332
|
test_plugins_metadata_loader.py
|
rafalp_Misago/misago/plugins/tests/test_plugins_metadata_loader.py
|
import pytest
from django.conf import settings
from ..metadata import PluginsMetadataLoader
@pytest.fixture
def plugins_metadata():
return PluginsMetadataLoader(settings.INSTALLED_PLUGINS)
def test_plugins_metadata_loader_returns_metadata_dict(plugins_metadata):
metadata = plugins_metadata.get_metadata()
assert metadata
def test_plugins_metadata_loader_caches_metadata(plugins_metadata):
metadata = plugins_metadata.get_metadata()
other_metadata = plugins_metadata.get_metadata()
assert id(metadata) == id(other_metadata)
def test_plugins_metadata_loader_handles_plugins_without_manifests(plugins_metadata):
metadata = plugins_metadata.get_metadata()
assert "minimal_plugin" in metadata
plugin_metadata = metadata["minimal_plugin"]
assert plugin_metadata.package == "minimal_plugin"
assert plugin_metadata.dirname == "minimal-plugin"
assert plugin_metadata.has_manifest == False
assert plugin_metadata.manifest_error is None
assert plugin_metadata.name is None
def test_plugins_metadata_loader_handles_plugins_with_empty_manifests(plugins_metadata):
metadata = plugins_metadata.get_metadata()
assert "empty_manifest_plugin" in metadata
plugin_metadata = metadata["empty_manifest_plugin"]
assert plugin_metadata.package == "empty_manifest_plugin"
assert plugin_metadata.dirname == "empty-manifest-plugin"
assert plugin_metadata.has_manifest == True
assert plugin_metadata.manifest_error is None
assert plugin_metadata.name is None
def test_plugins_metadata_loader_handles_plugins_with_full_manifests(plugins_metadata):
metadata = plugins_metadata.get_metadata()
assert "full_manifest_plugin" in metadata
plugin_metadata = metadata["full_manifest_plugin"]
assert plugin_metadata.package == "full_manifest_plugin"
assert plugin_metadata.dirname == "full-manifest-plugin"
assert plugin_metadata.has_manifest == True
assert plugin_metadata.manifest_error is None
assert plugin_metadata.name == "Example plugin with complete manifest"
def test_plugins_metadata_loader_handles_plugins_with_invalid_manifests(
plugins_metadata,
):
metadata = plugins_metadata.get_metadata()
assert "invalid_manifest_plugin" in metadata
plugin_metadata = metadata["invalid_manifest_plugin"]
assert plugin_metadata.package == "invalid_manifest_plugin"
assert plugin_metadata.dirname == "invalid-manifest-plugin"
assert plugin_metadata.has_manifest == False
assert plugin_metadata.manifest_error is not None
assert plugin_metadata.name is None
def test_plugins_metadata_loader_handles_empty_plugins_list():
plugins_metadata = PluginsMetadataLoader([])
metadata = plugins_metadata.get_metadata()
assert metadata == {}
assert id(metadata) == id(metadata)
| 2,820
|
Python
|
.py
| 56
| 45.910714
| 88
| 0.775793
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,333
|
conftest.py
|
rafalp_Misago/misago/plugins/tests/conftest.py
|
import pytest
from django.template import Context, Template
from ..outlets import PluginOutletHook, template_outlets
@pytest.fixture
def patch_outlets():
try:
org_outlets = template_outlets.copy()
for key in template_outlets:
template_outlets[key] = PluginOutletHook()
yield template_outlets
finally:
for key, hook in org_outlets.items():
template_outlets[key] = hook
@pytest.fixture
def render_outlet_template():
def render_outlet_template_function(context: dict | None = None):
template = Template(
"""
{% load misago_plugins %}
<div>{% pluginoutlet TEST %}</div>
"""
)
return template.render(Context(context or {})).strip()
return render_outlet_template_function
| 817
|
Python
|
.py
| 24
| 26.75
| 69
| 0.64631
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,334
|
test_plugin_metadata_creation.py
|
rafalp_Misago/misago/plugins/tests/test_plugin_metadata_creation.py
|
from .. import discover
from ..manifest import MisagoPlugin
from ..metadata import (
clean_plugin_color,
clean_plugin_icon,
clean_plugin_str,
clean_plugin_url,
create_plugin_metadata,
)
def test_plugin_metadata_is_created_without_manifest():
metadata = create_plugin_metadata("plugin_package", discover, None, None)
assert metadata.package == "plugin_package"
assert metadata.dirname == "misago"
assert metadata.has_manifest is False
assert metadata.manifest_error is None
assert metadata.name is None
assert metadata.description is None
assert metadata.license is None
assert metadata.icon is None
assert metadata.color is None
assert metadata.version is None
assert metadata.author is None
assert metadata.homepage is None
assert metadata.sponsor is None
assert metadata.help is None
assert metadata.bugs is None
assert metadata.repo is None
def test_plugin_metadata_is_created_with_manifest_error():
metadata = create_plugin_metadata(
"plugin_package", discover, None, "Not found error."
)
assert metadata.package == "plugin_package"
assert metadata.dirname == "misago"
assert metadata.has_manifest is False
assert metadata.manifest_error == "Not found error."
assert metadata.name is None
assert metadata.description is None
assert metadata.license is None
assert metadata.icon is None
assert metadata.color is None
assert metadata.version is None
assert metadata.author is None
assert metadata.homepage is None
assert metadata.sponsor is None
assert metadata.help is None
assert metadata.bugs is None
assert metadata.repo is None
def test_plugin_metadata_is_created_from_empty_manifest():
manifest = MisagoPlugin()
metadata = create_plugin_metadata(
"plugin_package",
discover,
manifest,
None,
)
assert metadata.package == "plugin_package"
assert metadata.dirname == "misago"
assert metadata.has_manifest is True
assert metadata.manifest_error is None
assert metadata.name is None
assert metadata.description is None
assert metadata.license is None
assert metadata.icon is None
assert metadata.color is None
assert metadata.version is None
assert metadata.author is None
assert metadata.homepage is None
assert metadata.sponsor is None
assert metadata.help is None
assert metadata.bugs is None
assert metadata.repo is None
def test_plugin_metadata_is_created_from_valid_full_manifest():
manifest = MisagoPlugin(
name="Test plugin",
description="Test plugin's manifest",
license="GNU GPL v2",
icon="fa fa-puzzle",
color="#FF00F0",
version="1.0",
author="Lorem Ipsum",
homepage="https://misago-project.org",
sponsor="https://sponsor.misago-project.org",
help="https://help.misago-project.org",
bugs="https://bugs.misago-project.org",
repo="https://repo.misago-project.org",
)
metadata = create_plugin_metadata(
"plugin_package",
discover,
manifest,
None,
)
assert metadata.package == "plugin_package"
assert metadata.dirname == "misago"
assert metadata.has_manifest is True
assert metadata.manifest_error is None
assert metadata.name == "Test plugin"
assert metadata.description == "Test plugin's manifest"
assert metadata.license == "GNU GPL v2"
assert metadata.icon == "fa fa-puzzle"
assert metadata.color == "#FF00F0"
assert metadata.version == "1.0"
assert metadata.author == "Lorem Ipsum"
assert metadata.homepage.netloc == "misago-project.org"
assert metadata.homepage.url == "https://misago-project.org"
assert metadata.sponsor.netloc == "sponsor.misago-project.org"
assert metadata.sponsor.url == "https://sponsor.misago-project.org"
assert metadata.help.netloc == "help.misago-project.org"
assert metadata.help.url == "https://help.misago-project.org"
assert metadata.bugs.netloc == "bugs.misago-project.org"
assert metadata.bugs.url == "https://bugs.misago-project.org"
assert metadata.repo.netloc == "repo.misago-project.org"
assert metadata.repo.url == "https://repo.misago-project.org"
def test_plugin_color_returns_none_if_manifest_value_is_none():
assert clean_plugin_color(None) is None
def test_plugin_color_returns_none_if_manifest_value_is_not_a_str():
assert clean_plugin_color([1, 2, 3]) is None
assert clean_plugin_color({}) is None
assert clean_plugin_color(False) is None
assert clean_plugin_color(42) is None
def test_plugin_color_returns_none_if_manifest_value_is_invalid_str():
assert clean_plugin_color("") is None
assert clean_plugin_color("red") is None
assert clean_plugin_color("#8823412") is None
assert clean_plugin_color("#zzzzzz") is None
assert clean_plugin_color("eke eke nii") is None
def test_plugin_color_returns_valid_manifest_color():
assert clean_plugin_color("#ffffff") == "#FFFFFF"
assert clean_plugin_color("#000000") == "#000000"
def test_plugin_icon_returns_none_if_manifest_value_is_none():
assert clean_plugin_icon(None) is None
def test_plugin_icon_returns_none_if_manifest_value_is_not_a_str():
assert clean_plugin_icon([1, 2, 3]) is None
assert clean_plugin_icon({}) is None
assert clean_plugin_icon(False) is None
assert clean_plugin_icon(42) is None
def test_plugin_icon_returns_none_if_manifest_value_is_invalid_str():
assert clean_plugin_icon("") is None
assert clean_plugin_icon("red") is None
assert clean_plugin_icon("bell clock") is None
assert clean_plugin_icon("fas other") is None
def test_plugin_icon_returns_valid_manifest_icon():
assert clean_plugin_icon("fa fa-test") == "fa fa-test"
assert clean_plugin_icon("fas fa-other-test") == "fas fa-other-test"
assert clean_plugin_icon("far fa-extra-test") == "far fa-extra-test"
def test_plugin_str_returns_none_if_manifest_value_is_none():
assert clean_plugin_str(None, 10) is None
def test_plugin_str_returns_none_if_manifest_value_is_not_a_str():
assert clean_plugin_str([1, 2, 3], 10) is None
assert clean_plugin_str({}, 10) is None
assert clean_plugin_str(False, 10) is None
assert clean_plugin_str(42, 10) is None
def test_plugin_str_returns_none_if_manifest_value_is_empty_str():
assert clean_plugin_str("", 10) is None
assert clean_plugin_str(" ", 10) is None
def test_plugin_str_returns_string_cut_to_length():
assert clean_plugin_str("Hello world", 15) == "Hello world"
assert clean_plugin_str("Hello world", 5) == "Hello"
def test_plugin_str_returns_string_with_whitespace_stripped():
assert clean_plugin_str(" Hello world ", 15) == "Hello world"
assert clean_plugin_str(" Hello world ", 5) == "Hello"
def test_plugin_url_returns_none_if_manifest_value_is_none():
assert clean_plugin_url(None) is None
def test_plugin_url_returns_none_if_manifest_value_is_not_a_str():
assert clean_plugin_url([1, 2, 3]) is None
assert clean_plugin_url({}) is None
assert clean_plugin_url(False) is None
assert clean_plugin_url(42) is None
def test_plugin_url_returns_none_if_manifest_value_is_invalid_str():
assert clean_plugin_url("") is None
assert clean_plugin_url("red") is None
assert clean_plugin_url("misago-project.org") is None
assert clean_plugin_url("www.misago-project.org") is None
assert clean_plugin_url('javascript:alert("test")') is None
assert clean_plugin_url("mailto:dot@exc.com") is None
assert clean_plugin_url("ftp://oke.com/guru") is None
def test_plugin_url_returns_url_if_manifest_value_is_supported_url():
http_url = clean_plugin_url("http://example.com")
assert http_url.netloc == "example.com"
assert http_url.url == "http://example.com"
https_url = clean_plugin_url("https://example.com")
assert https_url.netloc == "example.com"
assert https_url.url == "https://example.com"
comma_url = clean_plugin_url("https://example-site.com")
assert comma_url.netloc == "example-site.com"
assert comma_url.url == "https://example-site.com"
digits_url = clean_plugin_url("https://example-site365.com")
assert digits_url.netloc == "example-site365.com"
assert digits_url.url == "https://example-site365.com"
https_www_url = clean_plugin_url("https://www.example.com")
assert https_www_url.netloc == "www.example.com"
assert https_www_url.url == "https://www.example.com"
https_www_subdomains_url = clean_plugin_url("https://www.dev.stage.example.com")
assert https_www_subdomains_url.netloc == "www.dev.stage.example.com"
assert https_www_subdomains_url.url == "https://www.dev.stage.example.com"
http_php_url = clean_plugin_url("http://example.com/some/where.php")
assert http_php_url.netloc == "example.com"
assert http_php_url.url == "http://example.com/some/where.php"
http_path_url = clean_plugin_url("http://example.com/some-path/ok/123")
assert http_path_url.netloc == "example.com"
assert http_path_url.url == "http://example.com/some-path/ok/123"
http_fragment_url = clean_plugin_url("http://example.com/some-path/#ok-123")
assert http_fragment_url.netloc == "example.com"
assert http_fragment_url.url == "http://example.com/some-path/#ok-123"
http_query_url = clean_plugin_url("http://example.com/arg/?ok=yes&alt=no")
assert http_query_url.netloc == "example.com"
assert http_query_url.url == "http://example.com/arg/?ok=yes&alt=no"
| 9,647
|
Python
|
.py
| 207
| 41.410628
| 84
| 0.710678
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,335
|
test_template_tags.py
|
rafalp_Misago/misago/plugins/tests/test_template_tags.py
|
from django.template import Context, Template
from django.utils.safestring import mark_safe
from ..outlets import PluginOutlet, append_outlet_action, prepend_outlet_action
def strong_action(request, context):
body = context.get("value") or "none"
return mark_safe(f"<strong>{body}</strong>")
def em_action(request, context):
body = context.get("value") or "none"
return mark_safe(f"<em>{body}</em>")
def test_empty_outlet_renders_nothing(patch_outlets, render_outlet_template, snapshot):
html = render_outlet_template()
assert snapshot == html
def test_outlet_renders_appended_plugin(
patch_outlets, render_outlet_template, snapshot
):
append_outlet_action(PluginOutlet.TEST, strong_action)
html = render_outlet_template()
assert snapshot == html
def test_outlet_renders_prepended_plugin(
patch_outlets, render_outlet_template, snapshot
):
prepend_outlet_action(PluginOutlet.TEST, strong_action)
html = render_outlet_template()
assert snapshot == html
def test_outlet_renders_multiple_plugins(
patch_outlets, render_outlet_template, snapshot
):
append_outlet_action(PluginOutlet.TEST, strong_action)
prepend_outlet_action(PluginOutlet.TEST, em_action)
prepend_outlet_action(PluginOutlet.TEST, strong_action)
html = render_outlet_template()
assert snapshot == html
def test_outlet_renders_plugins_with_context(
patch_outlets, render_outlet_template, snapshot
):
append_outlet_action(PluginOutlet.TEST, strong_action)
prepend_outlet_action(PluginOutlet.TEST, em_action)
prepend_outlet_action(PluginOutlet.TEST, strong_action)
html = render_outlet_template({"value": "context"})
assert snapshot == html
def render_hasplugins_template(context: dict | None = None):
template = Template(
"""
{% load misago_plugins %}
<div>{% hasplugins TEST %}plugins{% endhasplugins %}</div>
"""
)
return template.render(Context(context or {})).strip()
def test_hasplugins_tag_renders_nothing_if_no_plugins_exist(patch_outlets, snapshot):
html = render_hasplugins_template()
assert snapshot == html
def test_hasplugins_tag_renders_value_if_plugins_exist(patch_outlets, snapshot):
append_outlet_action(PluginOutlet.TEST, strong_action)
html = render_hasplugins_template()
assert snapshot == html
def render_haspluginselse_template(context: dict | None = None):
template = Template(
"""
{% load misago_plugins %}
<div>{% hasplugins TEST %}plugins{% else %}noplugins{% endhasplugins %}</div>
"""
)
return template.render(Context(context or {})).strip()
def test_hasplugins_else_tag_renders_else_if_no_plugins_exist(patch_outlets, snapshot):
html = render_haspluginselse_template()
assert snapshot == html
def test_hasplugins_else_tag_renders_value_if_plugins_exist(patch_outlets, snapshot):
append_outlet_action(PluginOutlet.TEST, strong_action)
html = render_haspluginselse_template()
assert snapshot == html
| 3,055
|
Python
|
.py
| 70
| 38.8
| 87
| 0.733039
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,336
|
test_read_pip_install_file.py
|
rafalp_Misago/misago/plugins/tests/test_read_pip_install_file.py
|
from pathlib import Path
from tempfile import TemporaryDirectory
from ..discover import read_pip_install_file
def test_empty_pip_install_file_is_read_to_empty_list():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w"):
pass
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == []
def test_pip_install_file_is_read_without_comments_lines():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w") as fp:
fp.writelines(["# comment\n", "other\n"])
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == ["other"]
def test_pip_install_file_is_read_without_comments_after_content():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w") as fp:
fp.write("line # comment")
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == ["line"]
def test_pip_install_file_is_read_lines_trimmed():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w") as fp:
fp.writelines(["line \n", " other\n"])
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == ["line", "other"]
def test_pip_install_file_is_read_without_duplicate_lines():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w") as fp:
fp.writelines(["line\n", "other\n", "line\n"])
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == ["line", "other"]
def test_pip_install_file_is_read_without_version_data():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w") as fp:
fp.write("line==0.12rc1\n")
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == ["line"]
def test_pip_install_file_is_read_with_names_converted_to_package_names():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w") as fp:
fp.write("plugin-name\n")
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == ["plugin_name"]
def test_pip_install_file_is_read_with_blank_lines_skipped():
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
with open(pip_install_path, "w") as fp:
fp.write("plugin-name\n\nline")
file_contents = read_pip_install_file(pip_install_path)
assert file_contents == ["plugin_name", "line"]
| 3,115
|
Python
|
.py
| 59
| 44.864407
| 74
| 0.658858
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,337
|
test_action_hook.py
|
rafalp_Misago/misago/plugins/tests/test_action_hook.py
|
import pytest
from ..hooks import ActionHook
class MockActionHook(ActionHook):
def __call__(self, base: str):
return super().__call__(base)
def lowercase_action(base: str) -> str:
return base.lower()
def uppercase_action(base: str) -> str:
return base.upper()
def reverse_action(base: str) -> str:
return "".join(reversed(base))
@pytest.fixture
def hook():
return MockActionHook()
def test_action_hook_without_actions_returns_empty_list(hook):
assert hook("TeSt") == []
def test_action_hook_without_actions_is_falsy(hook):
assert not hook
def test_action_hook_with_actions_is_truthy(hook):
hook.append_action(lowercase_action)
assert hook
def test_action_hook_calls_action_and_returns_its_result(hook):
hook.append_action(lowercase_action)
assert hook("TeSt") == ["test"]
def test_action_hook_calls_multiple_actions_and_returns_their_results(hook):
hook.append_action(lowercase_action)
hook.append_action(uppercase_action)
assert hook("TeSt") == ["test", "TEST"]
def test_action_hook_action_can_be_prepended_before_other_actions(hook):
hook.prepend_action(uppercase_action)
hook.append_action(lowercase_action)
hook.prepend_action(reverse_action)
assert hook("TeSt") == ["tSeT", "TEST", "test"]
| 1,298
|
Python
|
.py
| 33
| 35.212121
| 76
| 0.727053
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,338
|
test_discover_plugins.py
|
rafalp_Misago/misago/plugins/tests/test_discover_plugins.py
|
from pathlib import Path
from tempfile import TemporaryDirectory
import pytest
from ..discover import discover_plugins
@pytest.fixture
def sys_mock(mocker):
mock = mocker.patch("misago.plugins.discover.sys")
mock.path = []
return mock
def test_discover_plugins_returns_empty_list_if_plugins_path_is_empty(sys_mock):
plugins = discover_plugins("")
assert plugins == []
def test_discover_plugins_doesnt_update_sys_path_if_plugins_path_is_empty(sys_mock):
assert not discover_plugins("")
assert sys_mock.path == []
def test_discover_plugins_returns_empty_list_if_plugins_path_doesnt_exist(sys_mock):
with TemporaryDirectory() as plugins_dir:
plugins = discover_plugins(str(Path(plugins_dir) / "doesnt_exist"))
assert plugins == []
def test_discover_plugins_doesnt_update_sys_path_if_plugins_path_doesnt_exist(sys_mock):
with TemporaryDirectory() as plugins_dir:
assert not discover_plugins(str(Path(plugins_dir) / "doesnt_exist"))
assert sys_mock.path == []
def test_discover_plugins_returns_empty_list_if_plugins_dir_is_empty(sys_mock):
with TemporaryDirectory() as plugins_dir:
plugins = discover_plugins(plugins_dir)
assert plugins == []
def test_discover_plugins_doesnt_update_sys_path_if_plugins_dir_is_empty(sys_mock):
with TemporaryDirectory() as plugins_dir:
assert not discover_plugins(plugins_dir)
assert sys_mock.path == []
def create_plugin(plugins_dir: str, dir_name: str, package_name: str) -> Path:
plugin_path = Path(plugins_dir) / dir_name
plugin_path.mkdir()
plugin_package_path = plugin_path / package_name
plugin_package_path.mkdir()
plugin_init_path = plugin_package_path / "__init__.py"
plugin_init_path.touch()
plugin_misago_marker_path = plugin_package_path / "misago_plugin.py"
plugin_misago_marker_path.touch()
return plugin_misago_marker_path
def test_discover_plugins_returns_plugins_list(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_plugin(plugins_dir, "mock-plugin", "mock_plugin")
create_plugin(plugins_dir, "other-plugin", "other_plugin")
plugins = discover_plugins(plugins_dir)
assert plugins == ["mock_plugin", "other_plugin"]
def test_discover_plugins_adds_plugins_to_python_path(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_plugin(plugins_dir, "mock-plugin", "mock_plugin")
create_plugin(plugins_dir, "other-plugin", "other_plugin")
assert discover_plugins(plugins_dir)
assert sys_mock.path == [
f"{plugins_dir}/mock-plugin",
f"{plugins_dir}/other-plugin",
]
def test_discover_plugins_doesnt_create_duplicates_in_python_path(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_plugin(plugins_dir, "mock-plugin", "mock_plugin")
create_plugin(plugins_dir, "other-plugin", "other_plugin")
sys_mock.path.append(f"{plugins_dir}/mock-plugin")
assert discover_plugins(plugins_dir)
assert sys_mock.path == [
f"{plugins_dir}/mock-plugin",
f"{plugins_dir}/other-plugin",
]
def test_discover_plugins_skips_packages_without_misago_plugin_py(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_plugin(plugins_dir, "mock-plugin", "mock_plugin")
other_plugin = create_plugin(plugins_dir, "other-plugin", "other_plugin")
other_plugin.unlink()
plugins = discover_plugins(plugins_dir)
assert plugins == ["mock_plugin"]
assert sys_mock.path == [f"{plugins_dir}/mock-plugin"]
def test_discover_plugins_returns_plugins_apps_sorted_by_name(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_plugin(plugins_dir, "mock-plugin", "mock_plugin")
create_plugin(plugins_dir, "other-plugin", "alpha_plugin")
plugins = discover_plugins(plugins_dir)
assert plugins == ["alpha_plugin", "mock_plugin"]
def test_discover_plugins_adds_plugins_to_python_path_ordered_by_app_name(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_plugin(plugins_dir, "mock-plugin", "mock_plugin")
create_plugin(plugins_dir, "other-plugin", "alpha_plugin")
assert discover_plugins(plugins_dir)
assert sys_mock.path == [
f"{plugins_dir}/other-plugin",
f"{plugins_dir}/mock-plugin",
]
def test_discover_plugins_skips_plugins_without_init(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_plugin(plugins_dir, "mock-plugin", "mock_plugin")
invalid_plugin_path = create_plugin(plugins_dir, "invalid-plugin", "invalid")
invalid_plugin_path_init = invalid_plugin_path.parent / "__init__.py"
invalid_plugin_path_init.unlink()
plugins = discover_plugins(plugins_dir)
assert plugins == ["mock_plugin"]
assert sys_mock.path == [f"{plugins_dir}/mock-plugin"]
def create_pip_install(plugins_dir: str, contents: list[str]):
with open(Path(plugins_dir) / "pip-install.txt", "w") as fp:
fp.write("\n".join(contents))
@pytest.mark.xfail(reason="requires misago-pypi-plugin installed to pass")
def test_discover_plugins_reads_plugins_from_pip_install_if_it_exists(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_pip_install(plugins_dir, ["misago-pypi-plugin"])
plugins = discover_plugins(plugins_dir)
assert plugins == ["misago_pypi_plugin"]
assert sys_mock.path == []
@pytest.mark.xfail(reason="requires misago-pypi-plugin installed to pass")
def test_discover_plugins_skips_pip_install_entries_that_arent_installed(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_pip_install(plugins_dir, ["misago-pypi-plugin", "misago-other-plugin"])
plugins = discover_plugins(plugins_dir)
assert plugins == ["misago_pypi_plugin"]
assert sys_mock.path == []
@pytest.mark.xfail(reason="requires misago-pypi-plugin installed to pass")
def test_discover_plugins_skips_pip_install_entries_that_arent_misago_plugins(sys_mock):
with TemporaryDirectory() as plugins_dir:
create_pip_install(plugins_dir, ["misago-pypi-plugin", "django"])
plugins = discover_plugins(plugins_dir)
assert plugins == ["misago_pypi_plugin"]
assert sys_mock.path == []
@pytest.mark.xfail(reason="requires misago-pypi-plugin installed to pass")
def test_discover_plugins_skips_pip_install_if_its_directory(sys_mock):
with TemporaryDirectory() as plugins_dir:
pip_install_path = Path(plugins_dir) / "pip-install.txt"
pip_install_path.mkdir()
plugins = discover_plugins(plugins_dir)
assert plugins == []
assert sys_mock.path == []
| 6,806
|
Python
|
.py
| 130
| 45.476923
| 88
| 0.69604
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,339
|
test_template_outlet_action.py
|
rafalp_Misago/misago/plugins/tests/test_template_outlet_action.py
|
from ..outlets import PluginOutlet, append_outlet_action, template_outlet_action
@template_outlet_action
def noop_action(request, context):
return None
def test_noop_template_action_renders_nothing(
patch_outlets, render_outlet_template, snapshot
):
append_outlet_action(PluginOutlet.TEST, noop_action)
html = render_outlet_template()
assert snapshot == html
@template_outlet_action
def template_name_action(request, context):
return "misago/template_outlet_action_test.html"
def test_template_name_action_renders_template_with_standard_context(
patch_outlets, render_outlet_template, snapshot
):
append_outlet_action(PluginOutlet.TEST, template_name_action)
html = render_outlet_template({"message": "Standard context"})
assert snapshot == html
@template_outlet_action
def template_name_context_action(request, context):
return "misago/template_outlet_action_test.html", {"message": "Custom context"}
def test_template_name_context_action_renders_template_with_updated_context(
patch_outlets, render_outlet_template, snapshot
):
append_outlet_action(PluginOutlet.TEST, template_name_context_action)
html = render_outlet_template({"message": "Standard context"})
assert snapshot == html
| 1,259
|
Python
|
.py
| 28
| 41.392857
| 83
| 0.778507
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,340
|
test_discover_plugins_urls.py
|
rafalp_Misago/misago/plugins/tests/test_discover_plugins_urls.py
|
from ..urlpatterns import discover_plugins_urlpatterns
def test_discover_plugins_urlpatterns_discovers_apps_with_urls():
urlpatterns = discover_plugins_urlpatterns(["misago.threads", "misago.users"])
assert len(urlpatterns) == 2
def test_discover_plugins_urlpatterns_skips_apps_without_urls():
urlpatterns = discover_plugins_urlpatterns(["misago.core"])
assert not urlpatterns
| 397
|
Python
|
.py
| 7
| 52.857143
| 82
| 0.784974
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,341
|
test_filter_hook.py
|
rafalp_Misago/misago/plugins/tests/test_filter_hook.py
|
import pytest
from ..hooks import FilterHook
ACTION = 0
FIRST_FILTER = 1
SECOND_FILTER = 2
class MockFilterHook(FilterHook):
def __call__(self, action):
return super().__call__(action, [])
def action(data):
return [ACTION]
def first_filter(action, data):
return [action(data), FIRST_FILTER]
def second_filter(action, data):
data = action(data)
return [action(data), SECOND_FILTER]
@pytest.fixture
def hook():
return MockFilterHook()
def test_filter_hook_without_filters_just_calls_action(hook):
assert hook(action) == [ACTION]
def test_filter_hook_without_actions_is_falsy(hook):
assert not hook
def test_filter_hook_with_actions_is_truthy(hook):
hook.append_filter(first_filter)
assert hook
def test_filter_hook_calls_filter_before_action(hook):
hook.append_filter(first_filter)
assert hook(action) == [[ACTION], FIRST_FILTER]
def test_filter_hook_calls_filters_in_order_of_adding(hook):
hook.append_filter(first_filter)
hook.append_filter(second_filter)
assert hook(action) == [[[ACTION], FIRST_FILTER], SECOND_FILTER]
def test_filter_can_be_inserted_before_other_filters(hook):
hook.append_filter(first_filter)
hook.prepend_filter(second_filter)
assert hook(action) == [[[ACTION], SECOND_FILTER], FIRST_FILTER]
| 1,318
|
Python
|
.py
| 36
| 32.722222
| 68
| 0.734499
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,342
|
__init__.py
|
rafalp_Misago/misago/plugins/admin/__init__.py
|
from django.urls import path
from django.utils.translation import pgettext_lazy
from .views import plugins_list
class MisagoAdminExtension:
def register_urlpatterns(self, urlpatterns):
urlpatterns.namespace("plugins/", "plugins")
urlpatterns.patterns("plugins", path("", plugins_list, name="index"))
def register_navigation_nodes(self, site):
site.add_node(
name=pgettext_lazy("admin node", "Plugins"),
icon="fa fa-cube",
after="settings:index",
namespace="plugins",
)
| 562
|
Python
|
.py
| 14
| 32.5
| 77
| 0.668508
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,343
|
views.py
|
rafalp_Misago/misago/plugins/admin/views.py
|
from ...admin.views import render
from ..metadata import plugins_metadata
def plugins_list(request):
return render(
request,
"misago/admin/plugins/list.html",
{"plugins": plugins_metadata.get_metadata().values()},
)
| 250
|
Python
|
.py
| 8
| 26
| 62
| 0.683333
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,344
|
test_plugins_list.py
|
rafalp_Misago/misago/plugins/admin/tests/test_plugins_list.py
|
from django.urls import reverse
from ....test import assert_contains
def test_plugins_list_contains_plugins(admin_client):
response = admin_client.get(reverse("misago:admin:plugins:index"))
assert_contains(response, "Example plugin")
assert_contains(response, "empty_manifest_plugin")
assert_contains(response, "invalid_manifest_plugin")
assert_contains(response, "minimal_plugin")
def test_plugins_list_contains_plugins_directories_and_packages(admin_client):
response = admin_client.get(reverse("misago:admin:plugins:index"))
assert_contains(response, "empty-manifest-plugin")
assert_contains(response, "empty_manifest_plugin")
assert_contains(response, "full-manifest-plugin")
assert_contains(response, "full_manifest_plugin")
assert_contains(response, "invalid-manifest-plugin")
assert_contains(response, "invalid_manifest_plugin")
assert_contains(response, "minimal-plugin")
assert_contains(response, "minimal_plugin")
def test_plugins_list_contains_plugins_metadata(admin_client):
response = admin_client.get(reverse("misago:admin:plugins:index"))
assert_contains(response, "Rafał Pitoń")
assert_contains(response, "0.1DEV")
assert_contains(response, "GNU GPL v2")
| 1,255
|
Python
|
.py
| 23
| 50
| 78
| 0.764321
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,345
|
models.py
|
rafalp_Misago/misago/acl/models.py
|
from django.db import models
from django.utils.translation import pgettext
from .cache import clear_acl_cache
def permissions_default():
return {}
class BaseRole(models.Model):
name = models.CharField(max_length=255)
special_role = models.CharField(max_length=255, null=True, blank=True)
permissions = models.JSONField(default=permissions_default)
class Meta:
abstract = True
def __str__(self):
return pgettext("role name", self.name)
def save(self, *args, **kwargs):
if self.pk:
clear_acl_cache()
return super().save(*args, **kwargs)
def delete(self, *args, **kwargs):
clear_acl_cache()
return super().delete(*args, **kwargs)
class Role(BaseRole):
pass
| 761
|
Python
|
.py
| 22
| 28.727273
| 74
| 0.675824
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,346
|
test.py
|
rafalp_Misago/misago/acl/test.py
|
from contextlib import ContextDecorator, ExitStack, contextmanager
from unittest.mock import patch
from .useracl import get_user_acl
__all__ = ["patch_user_acl"]
class patch_user_acl(ContextDecorator, ExitStack):
"""Testing utility that patches get_user_acl results
Can be used as decorator or context manager.
Patch should be a dict or callable.
"""
_acl_patches = []
def __init__(self, acl_patch):
super().__init__()
self.acl_patch = acl_patch
def patched_get_user_acl(self, user, cache_versions):
user_acl = get_user_acl(user, cache_versions)
self.apply_acl_patches(user, user_acl)
return user_acl
def apply_acl_patches(self, user, user_acl):
for acl_patch in self._acl_patches:
self.apply_acl_patch(user, user_acl, acl_patch)
def apply_acl_patch(self, user, user_acl, acl_patch):
if callable(acl_patch):
acl_patch(user, user_acl)
else:
user_acl.update(acl_patch)
def __enter__(self):
super().__enter__()
self.enter_context(self.enable_acl_patch())
self.enter_context(self.patch_user_acl())
@contextmanager
def enable_acl_patch(self):
try:
self._acl_patches.append(self.acl_patch)
yield
finally:
self._acl_patches.pop(-1)
def patch_user_acl(self):
return patch(
"misago.acl.useracl.get_user_acl", side_effect=self.patched_get_user_acl
)
| 1,510
|
Python
|
.py
| 40
| 30
| 84
| 0.634615
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,347
|
useracl.py
|
rafalp_Misago/misago/acl/useracl.py
|
import copy
from . import buildacl
from .cache import get_acl_cache, set_acl_cache
from .providers import providers
def get_user_acl(user, cache_versions):
user_acl = get_acl_cache(user, cache_versions)
if user_acl is None:
user_acl = buildacl.build_acl(user.get_roles())
set_acl_cache(user, cache_versions, user_acl)
user_acl["user_id"] = user.id
user_acl["is_authenticated"] = bool(user.is_authenticated)
user_acl["is_anonymous"] = bool(user.is_anonymous)
user_acl["is_admin"] = user.is_misago_admin
user_acl["is_root"] = user.is_misago_root
user_acl["cache_versions"] = cache_versions.copy()
return user_acl
def serialize_user_acl(user_acl):
"""serialize authenticated user's ACL"""
serialized_acl = copy.deepcopy(user_acl)
serialized_acl.pop("cache_versions")
for serializer in providers.get_user_acl_serializers():
serializer(serialized_acl)
return serialized_acl
| 956
|
Python
|
.py
| 23
| 36.782609
| 62
| 0.710583
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,348
|
apps.py
|
rafalp_Misago/misago/acl/apps.py
|
from django.apps import AppConfig
from .providers import providers
class MisagoACLsConfig(AppConfig):
name = "misago.acl"
label = "misago_acl"
verbose_name = "Misago ACL framework"
def ready(self):
providers.load()
| 243
|
Python
|
.py
| 8
| 25.875
| 41
| 0.727273
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,349
|
buildacl.py
|
rafalp_Misago/misago/acl/buildacl.py
|
from .providers import providers
def build_acl(roles):
"""build ACL for given roles"""
acl = {}
for extension, module in providers.list():
try:
acl = module.build_acl(acl, roles, extension)
except AttributeError:
message = "%s has to define build_acl function" % extension
raise AttributeError(message)
return acl
| 386
|
Python
|
.py
| 11
| 27.545455
| 71
| 0.638814
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,350
|
objectacl.py
|
rafalp_Misago/misago/acl/objectacl.py
|
from .providers import providers
def add_acl_to_obj(user_acl, obj):
"""add valid ACL to obj (iterable of objects or single object)"""
if hasattr(obj, "__iter__"):
for item in obj:
_add_acl_to_obj(user_acl, item)
else:
_add_acl_to_obj(user_acl, obj)
def _add_acl_to_obj(user_acl, obj):
"""add valid ACL to single obj, helper for add_acl function"""
obj.acl = {}
for annotator in providers.get_obj_type_annotators(obj):
annotator(user_acl, obj)
| 508
|
Python
|
.py
| 13
| 33.076923
| 69
| 0.640816
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,351
|
cache.py
|
rafalp_Misago/misago/acl/cache.py
|
from django.core.cache import cache
from . import ACL_CACHE
from ..cache.versions import invalidate_cache
def get_acl_cache(user, cache_versions):
key = get_cache_key(user, cache_versions)
return cache.get(key)
def set_acl_cache(user, cache_versions, user_acl):
key = get_cache_key(user, cache_versions)
cache.set(key, user_acl)
def get_cache_key(user, cache_versions):
return "acl_%s_%s" % (user.acl_key, cache_versions[ACL_CACHE])
def clear_acl_cache():
invalidate_cache(ACL_CACHE)
| 517
|
Python
|
.py
| 13
| 36.230769
| 66
| 0.735354
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,352
|
middleware.py
|
rafalp_Misago/misago/acl/middleware.py
|
from . import useracl
def user_acl_middleware(get_response):
"""Sets request.user_acl attribute with dict containing current user acl."""
def middleware(request):
request.user_acl = useracl.get_user_acl(request.user, request.cache_versions)
return get_response(request)
return middleware
| 320
|
Python
|
.py
| 7
| 40.142857
| 85
| 0.7411
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,353
|
providers.py
|
rafalp_Misago/misago/acl/providers.py
|
from importlib import import_module
from ..conf import settings
_NOT_INITIALIZED_ERROR = (
"PermissionProviders instance has to load providers with load() "
"before get_obj_type_annotators(), get_user_acl_serializers(), "
"list() or dict() methods will be available."
)
_ALREADY_INITIALIZED_ERROR = (
"PermissionProviders instance has already loaded providers and "
"acl_annotator or user_acl_serializer are no longer available."
)
class PermissionProviders:
"""manager for permission providers"""
def __init__(self):
self._initialized = False
self._providers = []
self._providers_dict = {}
self._annotators = {}
self._user_acl_serializers = []
def load(self):
if self._initialized:
raise RuntimeError("providers are already loaded")
self._register_providers()
self._coerce_dict_values_to_tuples(self._annotators)
self._user_acl_serializers = tuple(self._user_acl_serializers)
self._initialized = True
def _register_providers(self):
for namespace in settings.MISAGO_ACL_EXTENSIONS:
self._providers.append((namespace, import_module(namespace)))
self._providers_dict[namespace] = import_module(namespace)
if hasattr(self._providers_dict[namespace], "register_with"):
self._providers_dict[namespace].register_with(self)
def _coerce_dict_values_to_tuples(self, types_dict):
for hashType in types_dict.keys():
types_dict[hashType] = tuple(types_dict[hashType])
def acl_annotator(self, hashable_type, func):
"""registers ACL annotator for specified types"""
assert not self._initialized, _ALREADY_INITIALIZED_ERROR
self._annotators.setdefault(hashable_type, []).append(func)
def user_acl_serializer(self, func):
"""registers ACL serializer for specified types"""
assert not self._initialized, _ALREADY_INITIALIZED_ERROR
self._user_acl_serializers.append(func)
def get_obj_type_annotators(self, obj):
assert self._initialized, _NOT_INITIALIZED_ERROR
return self._annotators.get(obj.__class__, [])
def get_user_acl_serializers(self):
assert self._initialized, _NOT_INITIALIZED_ERROR
return self._user_acl_serializers
def list(self):
assert self._initialized, _NOT_INITIALIZED_ERROR
return self._providers
def dict(self):
assert self._initialized, _NOT_INITIALIZED_ERROR
return self._providers_dict
providers = PermissionProviders()
| 2,592
|
Python
|
.py
| 56
| 38.714286
| 73
| 0.683625
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,354
|
panels.py
|
rafalp_Misago/misago/acl/panels.py
|
from debug_toolbar.panels import Panel
from django.utils.translation import pgettext_lazy
class MisagoACLPanel(Panel):
"""panel that displays current user's ACL"""
title = pgettext_lazy("debug toolbar", "Misago User ACL")
template = "misago/acl_debug.html"
@property
def nav_subtitle(self):
misago_user = self.get_stats().get("misago_user")
if misago_user and misago_user.is_authenticated:
return misago_user.username
return pgettext_lazy("debug toolbar", "Anonymous user")
def generate_stats(self, request, response):
try:
misago_user = request.user
except AttributeError:
misago_user = None
try:
misago_acl = request.user_acl
except AttributeError:
misago_acl = {}
self.record_stats({"misago_user": misago_user, "misago_acl": misago_acl})
| 897
|
Python
|
.py
| 22
| 32.681818
| 81
| 0.657439
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,355
|
algebra.py
|
rafalp_Misago/misago/acl/algebra.py
|
def _roles_acls(key_name, roles):
acls = []
for role in roles:
role_permissions = role.permissions.get(key_name)
if role_permissions:
acls.append(role_permissions)
return acls
def sum_acls(result_acl, acls=None, roles=None, key=None, **permissions):
if acls and roles:
raise ValueError('You can not provide both "acls" and "roles" arguments')
if (acls is None) and (roles is None):
raise ValueError('You have to provide either "acls" and "roles" argument')
if roles is not None:
if not key:
raise ValueError(
'You have to provide "key" argument if you '
"are passing roles instead of acls"
)
acls = _roles_acls(key, roles)
for permission, compare in permissions.items():
try:
permission_value = result_acl[permission]
except KeyError:
message = 'Default value for permission "%s" is not provided'
raise ValueError(message % permission)
for acl in acls:
try:
permission_value = compare(permission_value, acl[permission])
except KeyError:
pass
result_acl[permission] = permission_value
return result_acl
# Common comparisions
def greater(a, b):
return a if a > b else b
def greater_or_zero(a, b):
if a == 0:
return a
if b == 0:
return b
return greater(a, b)
def lower(a, b):
return a if a < b else b
def lower_non_zero(a, b):
if a == 0:
return b
if b == 0:
return a
return lower(a, b)
| 1,634
|
Python
|
.py
| 49
| 25.183673
| 82
| 0.598089
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,356
|
decorators.py
|
rafalp_Misago/misago/acl/decorators.py
|
from django.core.exceptions import PermissionDenied
from django.http import Http404
def return_boolean(f):
def decorator(*args, **kwargs):
try:
f(*args, **kwargs)
except (Http404, PermissionDenied):
return False
else:
return True
return decorator
| 318
|
Python
|
.py
| 11
| 21.454545
| 51
| 0.641447
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,357
|
0002_acl_version_tracker.py
|
rafalp_Misago/misago/acl/migrations/0002_acl_version_tracker.py
|
from django.db import migrations
class Migration(migrations.Migration):
"""Superseded by 0004"""
dependencies = [("misago_acl", "0001_initial"), ("misago_core", "0001_initial")]
operations = []
| 210
|
Python
|
.py
| 5
| 37.8
| 84
| 0.696517
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,358
|
0004_cache_version.py
|
rafalp_Misago/misago/acl/migrations/0004_cache_version.py
|
# -*- coding: utf-8 -*-
from django.db import migrations
from .. import ACL_CACHE
from ...cache.operations import StartCacheVersioning
class Migration(migrations.Migration):
dependencies = [
("misago_acl", "0003_default_roles"),
("misago_cache", "0001_initial"),
]
operations = [StartCacheVersioning(ACL_CACHE)]
| 344
|
Python
|
.py
| 10
| 30.2
| 52
| 0.7
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,359
|
0003_default_roles.py
|
rafalp_Misago/misago/acl/migrations/0003_default_roles.py
|
from django.db import migrations
pgettext_lazy = lambda c, s: s
def create_default_roles(apps, schema_editor):
Role = apps.get_model("misago_acl", "Role")
Role.objects.create(
name=pgettext_lazy("role name", "Member"),
special_role="authenticated",
permissions={
# account
"misago.users.permissions.account": {
"name_changes_allowed": 2,
"name_changes_expire": 180,
"can_have_signature": 0,
"allow_signature_links": 0,
"allow_signature_images": 0,
},
# profiles
"misago.users.permissions.profiles": {
"can_browse_users_list": 1,
"can_search_users": 1,
"can_follow_users": 1,
"can_be_blocked": 1,
"can_see_users_name_history": 0,
"can_see_users_emails": 0,
"can_see_users_ips": 0,
"can_see_hidden_users": 0,
},
# attachments
"misago.threads.permissions.attachments": {
"max_attachment_size": 4 * 1024,
"can_download_other_users_attachments": True,
},
# polls
"misago.threads.permissions.polls": {
"can_start_polls": 1,
"can_edit_polls": 1,
},
# search
"misago.search.permissions": {"can_search": 1},
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Guest"),
special_role="anonymous",
permissions={
# account
"misago.users.permissions.account": {
"name_changes_allowed": 0,
"name_changes_expire": 0,
"can_have_signature": 0,
"allow_signature_links": 0,
"allow_signature_images": 0,
},
# profiles
"misago.users.permissions.profiles": {
"can_browse_users_list": 1,
"can_search_users": 1,
"can_see_users_name_history": 0,
"can_see_users_emails": 0,
"can_see_users_ips": 0,
"can_see_hidden_users": 0,
},
# attachments
"misago.threads.permissions.attachments": {
"can_download_other_users_attachments": True
},
# search
"misago.search.permissions": {"can_search": 1},
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Moderator"),
permissions={
# account
"misago.users.permissions.account": {
"name_changes_allowed": 5,
"name_changes_expire": 14,
"can_have_signature": 1,
"allow_signature_links": 1,
"allow_signature_images": 0,
},
# profiles
"misago.users.permissions.profiles": {
"can_browse_users_list": 1,
"can_search_users": 1,
"can_be_blocked": 0,
"can_see_users_name_history": 1,
"can_see_ban_details": 1,
"can_see_users_emails": 1,
"can_see_users_ips": 1,
"can_see_hidden_users": 1,
},
# attachments
"misago.threads.permissions.attachments": {
"max_attachment_size": 8 * 1024,
"can_download_other_users_attachments": True,
"can_delete_other_users_attachments": True,
},
# polls
"misago.threads.permissions.polls": {
"can_start_polls": 2,
"can_edit_polls": 2,
"can_delete_polls": 2,
"can_always_see_poll_voters": 1,
},
# moderation
"misago.threads.permissions.threads": {
"can_see_unapproved_content_lists": True,
"can_see_reported_content_lists": True,
"can_omit_flood_protection": True,
},
"misago.users.permissions.moderation": {
"can_warn_users": 1,
"can_moderate_avatars": 1,
"can_moderate_signatures": 1,
"can_moderate_profile_details": 1,
},
# delete users
"misago.users.permissions.delete": {
"can_delete_users_newer_than": 0,
"can_delete_users_with_less_posts_than": 0,
},
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Renaming users"),
permissions={
# rename users
"misago.users.permissions.moderation": {"can_rename_users": 1}
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Banning users"),
permissions={
# ban users
"misago.users.permissions.profiles": {"can_see_ban_details": 1},
"misago.users.permissions.moderation": {
"can_ban_users": 1,
"max_ban_length": 14,
"can_lift_bans": 1,
"max_lifted_ban_length": 14,
},
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Deleting users"),
permissions={
# delete users
"misago.users.permissions.delete": {
"can_delete_users_newer_than": 3,
"can_delete_users_with_less_posts_than": 7,
}
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Can't be blocked"),
permissions={
# profiles
"misago.users.permissions.profiles": {"can_be_blocked": 0}
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Private threads"),
permissions={
# private threads
"misago.threads.permissions.privatethreads": {
"can_use_private_threads": 1,
"can_start_private_threads": 1,
"max_private_thread_participants": 3,
"can_add_everyone_to_private_threads": 0,
"can_report_private_threads": 1,
"can_moderate_private_threads": 0,
}
},
)
Role.objects.create(
name=pgettext_lazy("role name", "Private threads moderator"),
permissions={
# private threads
"misago.threads.permissions.privatethreads": {
"can_use_private_threads": 1,
"can_start_private_threads": 1,
"max_private_thread_participants": 15,
"can_add_everyone_to_private_threads": 1,
"can_report_private_threads": 1,
"can_moderate_private_threads": 1,
}
},
)
class Migration(migrations.Migration):
dependencies = [("misago_acl", "0002_acl_version_tracker")]
operations = [migrations.RunPython(create_default_roles)]
| 7,060
|
Python
|
.py
| 192
| 23.838542
| 76
| 0.497446
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,360
|
0001_initial.py
|
rafalp_Misago/misago/acl/migrations/0001_initial.py
|
from django.db import migrations, models
from ..models import permissions_default
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="Role",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("name", models.CharField(max_length=255)),
(
"special_role",
models.CharField(max_length=255, null=True, blank=True),
),
("permissions", models.JSONField(default=permissions_default)),
],
options={"abstract": False},
bases=(models.Model,),
)
]
| 954
|
Python
|
.py
| 29
| 18.482759
| 79
| 0.451087
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,361
|
test_getting_user_acl.py
|
rafalp_Misago/misago/acl/tests/test_getting_user_acl.py
|
from ..useracl import get_user_acl
def test_getter_returns_authenticated_user_acl(cache_versions, user):
acl = get_user_acl(user, cache_versions)
assert acl
assert acl["user_id"] == user.id
assert acl["is_authenticated"] is True
assert acl["is_anonymous"] is False
def test_user_acl_excludes_admin_and_root_status(cache_versions, user):
acl = get_user_acl(user, cache_versions)
assert acl
assert acl["is_admin"] is False
assert acl["is_root"] is False
def test_user_acl_includes_cache_versions(cache_versions, user):
acl = get_user_acl(user, cache_versions)
assert acl
assert acl["cache_versions"] == cache_versions
def test_getter_returns_anonymous_user_acl(db, cache_versions, anonymous_user):
acl = get_user_acl(anonymous_user, cache_versions)
assert acl
assert acl["user_id"] == anonymous_user.id
assert acl["is_authenticated"] is False
assert acl["is_anonymous"] is True
def test_admin_acl_includes_admin_but_not_root_status(cache_versions, admin):
acl = get_user_acl(admin, cache_versions)
assert acl
assert acl["is_admin"] is True
assert acl["is_root"] is False
def test_root_admin_acl_includes_admin_and_root_true_status(cache_versions, root_admin):
acl = get_user_acl(root_admin, cache_versions)
assert acl
assert acl["is_admin"] is True
assert acl["is_root"] is True
def test_getter_returns_acl_from_cache(mocker, db, cache_versions, anonymous_user):
cache_get = mocker.patch("django.core.cache.cache.get", return_value=dict())
get_user_acl(anonymous_user, cache_versions)
cache_get.assert_called_once()
def test_getter_builds_new_acl_when_cache_is_not_available(
mocker, cache_versions, user
):
mocker.patch("django.core.cache.cache.set")
mocker.patch("misago.acl.buildacl.build_acl", return_value=dict())
cache_get = mocker.patch("django.core.cache.cache.get", return_value=None)
get_user_acl(user, cache_versions)
cache_get.assert_called_once()
def test_getter_sets_new_cache_if_no_cache_is_set(
mocker, db, cache_versions, anonymous_user
):
cache_set = mocker.patch("django.core.cache.cache.set")
mocker.patch("misago.acl.buildacl.build_acl", return_value=dict())
mocker.patch("django.core.cache.cache.get", return_value=None)
get_user_acl(anonymous_user, cache_versions)
cache_set.assert_called_once()
def test_acl_cache_name_includes_cache_version(
mocker, db, cache_versions, anonymous_user
):
cache_set = mocker.patch("django.core.cache.cache.set")
mocker.patch("misago.acl.buildacl.build_acl", return_value=dict())
mocker.patch("django.core.cache.cache.get", return_value=None)
get_user_acl(anonymous_user, cache_versions)
cache_key = cache_set.call_args[0][0]
assert cache_versions["acl"] in cache_key
def test_getter_is_not_setting_new_cache_if_cache_is_set(
mocker, cache_versions, anonymous_user
):
cache_set = mocker.patch("django.core.cache.cache.set")
mocker.patch("django.core.cache.cache.get", return_value=dict())
get_user_acl(anonymous_user, cache_versions)
cache_set.assert_not_called()
| 3,158
|
Python
|
.py
| 68
| 41.911765
| 88
| 0.728908
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,362
|
test_user_acl_middleware.py
|
rafalp_Misago/misago/acl/tests/test_user_acl_middleware.py
|
from unittest.mock import Mock
from ..middleware import user_acl_middleware
def test_middleware_sets_attr_on_request(cache_versions, user):
get_response = Mock()
request = Mock(user=user, cache_versions=cache_versions)
middleware = user_acl_middleware(get_response)
middleware(request)
assert request.user_acl
def test_middleware_calls_get_response(cache_versions, user):
get_response = Mock()
request = Mock(user=user, cache_versions=cache_versions)
middleware = user_acl_middleware(get_response)
middleware(request)
get_response.assert_called_once()
| 597
|
Python
|
.py
| 14
| 38.428571
| 63
| 0.762976
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,363
|
test_user_acl_context_processor.py
|
rafalp_Misago/misago/acl/tests/test_user_acl_context_processor.py
|
from unittest.mock import Mock
from ..context_processors import user_acl
def test_context_processor_adds_request_user_acl_to_context():
test_acl = {"test": True}
context = user_acl(Mock(user_acl=test_acl))
assert context == {"user_acl": test_acl}
| 262
|
Python
|
.py
| 6
| 40.166667
| 62
| 0.727273
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,364
|
test_providers.py
|
rafalp_Misago/misago/acl/tests/test_providers.py
|
import pytest
from ...conf import settings
from ..providers import PermissionProviders
def test_providers_are_not_loaded_on_container_init():
providers = PermissionProviders()
assert not providers._initialized
assert not providers._providers
assert not providers._annotators
assert not providers._user_acl_serializers
def test_container_loads_providers():
providers = PermissionProviders()
providers.load()
assert providers._providers
assert providers._annotators
assert providers._user_acl_serializers
def test_loading_providers_second_time_raises_runtime_error():
providers = PermissionProviders()
providers.load()
with pytest.raises(RuntimeError):
providers.load()
def test_container_returns_list_of_providers():
providers = PermissionProviders()
providers.load()
providers_setting = settings.MISAGO_ACL_EXTENSIONS
assert len(providers.list()) == len(providers_setting)
def test_container_returns_dict_of_providers():
providers = PermissionProviders()
providers.load()
providers_setting = settings.MISAGO_ACL_EXTENSIONS
assert len(providers.dict()) == len(providers_setting)
def test_accessing_providers_list_before_load_raises_assertion_error():
providers = PermissionProviders()
with pytest.raises(AssertionError):
providers.list()
def test_accessing_providers_dict_before_load_raises_assertion_error():
providers = PermissionProviders()
with pytest.raises(AssertionError):
providers.dict()
def test_getter_returns_registered_type_annotator():
class TestType:
pass
def test_annotator():
pass
providers = PermissionProviders()
providers.acl_annotator(TestType, test_annotator)
providers.load()
assert test_annotator in providers.get_obj_type_annotators(TestType())
def test_container_returns_list_of_user_acl_serializers():
providers = PermissionProviders()
providers.load()
assert providers.get_user_acl_serializers()
def test_getter_returns_registered_user_acl_serializer():
def test_user_acl_serializer():
pass
providers = PermissionProviders()
providers.user_acl_serializer(test_user_acl_serializer)
providers.load()
assert test_user_acl_serializer in providers.get_user_acl_serializers()
| 2,333
|
Python
|
.py
| 58
| 35.155172
| 75
| 0.758805
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,365
|
test_acl_algebra.py
|
rafalp_Misago/misago/acl/tests/test_acl_algebra.py
|
from .. import algebra
def test_greatest_value_is_returned():
assert algebra.greater(1, 3) == 3
assert algebra.greater(4, 2) == 4
assert algebra.greater(2, 2) == 2
assert algebra.greater(True, False) is True
def test_greatest_or_zero_value_is_returned():
assert algebra.greater_or_zero(1, 3) == 3
assert algebra.greater_or_zero(4, 2) == 4
assert algebra.greater_or_zero(2, 2) == 2
assert algebra.greater_or_zero(True, False) is False
assert algebra.greater_or_zero(2, 0) == 0
assert algebra.greater_or_zero(0, 0) == 0
assert algebra.greater_or_zero(0, 120) == 0
def test_lower_value_is_returned():
assert algebra.lower(1, 3) == 1
assert algebra.lower(4, 2) == 2
assert algebra.lower(2, 2) == 2
assert algebra.lower(True, False) is False
def test_lowest_non_zero_value_is_returned():
assert algebra.lower_non_zero(1, 3) == 1
assert algebra.lower_non_zero(0, 2) == 2
assert algebra.lower_non_zero(1, 2) == 1
assert algebra.lower_non_zero(0, 0) == 0
def test_acls_are_be_added_together():
test_acls = [
{
"can_see": 0,
"can_hear": 0,
"max_speed": 10,
"min_age": 16,
"speed_limit": 50,
},
{"can_see": 1, "can_hear": 0, "max_speed": 40, "min_age": 20, "speed_limit": 0},
{
"can_see": 0,
"can_hear": 1,
"max_speed": 80,
"min_age": 18,
"speed_limit": 40,
},
]
defaults = {
"can_see": 0,
"can_hear": 0,
"max_speed": 30,
"min_age": 18,
"speed_limit": 60,
}
acl = algebra.sum_acls(
defaults,
acls=test_acls,
can_see=algebra.greater,
can_hear=algebra.greater,
max_speed=algebra.greater,
min_age=algebra.lower,
speed_limit=algebra.greater_or_zero,
)
assert acl["can_see"] == 1
assert acl["can_hear"] == 1
assert acl["max_speed"] == 80
assert acl["min_age"] == 16
assert acl["speed_limit"] == 0
| 2,071
|
Python
|
.py
| 63
| 25.698413
| 88
| 0.569925
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,366
|
test_patching_user_acl.py
|
rafalp_Misago/misago/acl/tests/test_patching_user_acl.py
|
from .. import useracl
from ..test import patch_user_acl
def callable_acl_patch(user, user_acl):
user_acl["patched_for_user_id"] = user.id
@patch_user_acl({"is_patched": True})
def test_decorator_patches_all_users_acls_in_test(cache_versions, user):
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["is_patched"]
def test_decorator_removes_patches_after_test(cache_versions, user):
@patch_user_acl({"is_patched": True})
def test_function():
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["is_patched"]
test_function()
user_acl = useracl.get_user_acl(user, cache_versions)
assert "is_patched" not in user_acl
def test_context_manager_patches_all_users_acls_in_test(cache_versions, user):
with patch_user_acl({"can_rename_users": "patched"}):
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["can_rename_users"] == "patched"
def test_context_manager_removes_patches_after_exit(cache_versions, user):
with patch_user_acl({"is_patched": True}):
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["is_patched"]
user_acl = useracl.get_user_acl(user, cache_versions)
assert "is_patched" not in user_acl
@patch_user_acl(callable_acl_patch)
def test_callable_patch_is_called_with_user_and_acl_by_decorator(cache_versions, user):
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["patched_for_user_id"] == user.id
def test_callable_patch_is_called_with_user_and_acl_by_context_manager(
cache_versions, user
):
with patch_user_acl(callable_acl_patch):
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["patched_for_user_id"] == user.id
@patch_user_acl({"acl_patch": 1})
@patch_user_acl({"acl_patch": 2})
def test_multiple_acl_patches_applied_by_decorator_stack(cache_versions, user):
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["acl_patch"] == 2
def test_multiple_acl_patches_applied_by_context_manager_stack(cache_versions, user):
with patch_user_acl({"acl_patch": 1}):
with patch_user_acl({"acl_patch": 2}):
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["acl_patch"] == 2
user_acl = useracl.get_user_acl(user, cache_versions)
assert user_acl["acl_patch"] == 1
user_acl = useracl.get_user_acl(user, cache_versions)
assert "acl_patch" not in user_acl
| 2,530
|
Python
|
.py
| 50
| 45.28
| 87
| 0.700407
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,367
|
test_serializing_user_acl.py
|
rafalp_Misago/misago/acl/tests/test_serializing_user_acl.py
|
import json
from ..useracl import get_user_acl, serialize_user_acl
def test_user_acl_is_serializeable(cache_versions, user):
acl = get_user_acl(user, cache_versions)
assert serialize_user_acl(acl)
def test_user_acl_is_json_serializeable(cache_versions, user):
acl = get_user_acl(user, cache_versions)
serialized_acl = serialize_user_acl(acl)
assert json.dumps(serialized_acl)
| 401
|
Python
|
.py
| 9
| 40.777778
| 62
| 0.75969
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,368
|
test.py
|
rafalp_Misago/misago/acl/admin/test.py
|
from .forms import get_permissions_forms
def mock_role_form_data(model, data):
"""
In order for form to don't fail submission, all permission fields need
to receive values. This function populates data dict with default values
for permissions, making form validation pass
"""
for form in get_permissions_forms(model):
for field in form:
if field.value() is True:
data[field.html_name] = 1
elif field.value() is False:
data[field.html_name] = 0
else:
data[field.html_name] = field.value()
return data
| 622
|
Python
|
.py
| 16
| 30.25
| 76
| 0.630795
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,369
|
__init__.py
|
rafalp_Misago/misago/acl/admin/__init__.py
|
from django.urls import path
from django.utils.translation import pgettext_lazy
from .views import DeleteRole, EditRole, NewRole, RolesList, RoleUsers
class MisagoAdminExtension:
def register_urlpatterns(self, urlpatterns):
# Permissions section
urlpatterns.namespace("permissions/", "permissions")
# Roles
urlpatterns.patterns(
"permissions",
path("", RolesList.as_view(), name="index"),
path("new/", NewRole.as_view(), name="new"),
path("edit/<int:pk>/", EditRole.as_view(), name="edit"),
path("users/<int:pk>/", RoleUsers.as_view(), name="users"),
path("delete/<int:pk>/", DeleteRole.as_view(), name="delete"),
)
def register_navigation_nodes(self, site):
site.add_node(
name=pgettext_lazy("admin node", "Permissions"),
icon="fa fa-adjust",
after="moderators:index",
namespace="permissions",
)
| 986
|
Python
|
.py
| 23
| 33.652174
| 74
| 0.612735
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,370
|
forms.py
|
rafalp_Misago/misago/acl/admin/forms.py
|
from django import forms
from django.utils.translation import pgettext_lazy
from ..models import Role
from ..providers import providers
class RoleForm(forms.ModelForm):
name = forms.CharField(label=pgettext_lazy("admin role form", "Role name"))
class Meta:
model = Role
fields = ["name"]
def get_permissions_forms(role, data=None):
"""utility function for building forms in admin"""
role_permissions = role.permissions
perms_forms = []
for extension, module in providers.list():
try:
module.change_permissions_form
except AttributeError:
message = "'%s' object has no attribute '%s'"
raise AttributeError(message % (extension, "change_permissions_form"))
FormType = module.change_permissions_form(role)
if FormType:
if data:
form = FormType(data, prefix=extension)
else:
form = FormType(
initial=role_permissions.get(extension), prefix=extension
)
perms_forms.append(form)
return perms_forms
| 1,118
|
Python
|
.py
| 29
| 29.758621
| 82
| 0.640408
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,371
|
views.py
|
rafalp_Misago/misago/acl/admin/views.py
|
from django.contrib import messages
from django.shortcuts import redirect
from django.urls import reverse
from django.utils.translation import pgettext_lazy
from ...admin.views import generic
from ..models import Role
from .forms import RoleForm, get_permissions_forms
class RoleAdmin(generic.AdminBaseMixin):
root_link = "misago:admin:permissions:index"
model = Role
templates_dir = "misago/admin/roles"
message_404 = pgettext_lazy("admin roles", "Requested role does not exist.")
class RolesList(RoleAdmin, generic.ListView):
ordering = (("name", None),)
class RoleFormMixin:
def real_dispatch(self, request, target):
form = RoleForm(instance=target)
perms_forms = get_permissions_forms(target)
if request.method == "POST":
perms_forms = get_permissions_forms(target, request.POST)
valid_forms = 0
for permissions_form in perms_forms:
if permissions_form.is_valid():
valid_forms += 1
form = RoleForm(request.POST, instance=target)
if form.is_valid() and len(perms_forms) == valid_forms:
new_permissions = {}
for permissions_form in perms_forms:
cleaned_data = permissions_form.cleaned_data
new_permissions[permissions_form.prefix] = cleaned_data
form.instance.permissions = new_permissions
form.instance.save()
messages.success(request, self.message_submit % {"name": target.name})
if "stay" in request.POST:
return redirect(request.path)
return redirect(self.root_link)
if form.is_valid() and len(perms_forms) != valid_forms:
form.add_error(
None, pgettext_lazy("admin form", "Form contains errors.")
)
template_name = self.get_template_name(request, target)
return self.render(
request,
{"form": form, "target": target, "perms_forms": perms_forms},
template_name,
)
class NewRole(RoleFormMixin, RoleAdmin, generic.ModelFormView):
message_submit = pgettext_lazy("admin roles", 'New role "%(name)s" has been saved.')
class EditRole(RoleFormMixin, RoleAdmin, generic.ModelFormView):
message_submit = pgettext_lazy("admin roles", 'Role "%(name)s" has been changed.')
class DeleteRole(RoleAdmin, generic.ButtonView):
def check_permissions(self, request, target):
if target.special_role:
message = pgettext_lazy(
"admin roles", 'Role "%(name)s" is special role and can\'t be deleted.'
)
return message % {"name": target.name}
def button_action(self, request, target):
target.delete()
message = pgettext_lazy("admin roles", 'Role "%(name)s" has been deleted.')
messages.success(request, message % {"name": target.name})
class RoleUsers(RoleAdmin, generic.TargetedView):
def real_dispatch(self, request, target):
redirect_url = reverse("misago:admin:users:index")
return redirect("%s?role=%s" % (redirect_url, target.pk))
| 3,201
|
Python
|
.py
| 65
| 39.276923
| 88
| 0.640218
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,372
|
test_mock_role_admin_form_data.py
|
rafalp_Misago/misago/acl/admin/tests/test_mock_role_admin_form_data.py
|
from ...models import Role
from ..test import mock_role_form_data
def test_factory_for_change_role_permissions_form_data():
test_data = mock_role_form_data(Role(), {"can_fly": 1})
assert "can_fly" in test_data
| 220
|
Python
|
.py
| 5
| 41
| 59
| 0.71831
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,373
|
test_admin_views.py
|
rafalp_Misago/misago/acl/admin/tests/test_admin_views.py
|
import pytest
from django.urls import reverse
from ....admin.test import AdminTestCase
from ....cache.test import assert_invalidates_cache
from ....test import assert_contains
from ... import ACL_CACHE
from ...models import Role
from ..test import mock_role_form_data
admin_link = reverse("misago:admin:permissions:index")
def create_form_data(data_dict):
return mock_role_form_data(Role(), data_dict)
def test_link_is_registered_in_admin_nav(admin_client):
response = admin_client.get(reverse("misago:admin:index"))
assert_contains(response, admin_link)
def test_list_renders(admin_client):
response = admin_client.get(admin_link)
assert response.status_code == 200
def test_new_role_form_renders(admin_client):
response = admin_client.get(reverse("misago:admin:permissions:new"))
assert response.status_code == 200
def test_new_role_can_be_created(admin_client):
response = admin_client.post(
reverse("misago:admin:permissions:new"),
data=create_form_data({"name": "Test Role"}),
)
Role.objects.get(name="Test Role")
@pytest.fixture
def role(db):
return Role.objects.create(name="Test Role")
def test_edit_role_form_renders(admin_client, role):
response = admin_client.get(
reverse("misago:admin:permissions:edit", kwargs={"pk": role.pk})
)
assert response.status_code == 200
def test_role_can_be_edited(admin_client, role):
response = admin_client.post(
reverse("misago:admin:permissions:edit", kwargs={"pk": role.pk}),
data=create_form_data({"name": "Edited Role"}),
)
role.refresh_from_db()
assert role.name == "Edited Role"
def test_editing_role_invalidates_acl_cache(admin_client, role):
with assert_invalidates_cache(ACL_CACHE):
admin_client.post(
reverse("misago:admin:permissions:edit", kwargs={"pk": role.pk}),
data=create_form_data({"name": "Role"}),
)
def test_role_can_be_deleted(admin_client, role):
admin_client.post(
reverse("misago:admin:permissions:delete", kwargs={"pk": role.pk})
)
with pytest.raises(Role.DoesNotExist):
role.refresh_from_db()
def test_special_role_cant_be_deleted(admin_client, role):
role.special_role = "Test"
role.save()
admin_client.post(
reverse("misago:admin:permissions:delete", kwargs={"pk": role.pk})
)
role.refresh_from_db()
def test_deleting_role_invalidates_acl_cache(admin_client, role):
with assert_invalidates_cache(ACL_CACHE):
admin_client.post(
reverse("misago:admin:permissions:delete", kwargs={"pk": role.pk})
)
def test_users_with_role_view_redirects_to_admin_users_list(admin_client, role):
response = admin_client.get(
reverse("misago:admin:permissions:users", kwargs={"pk": role.pk})
)
assert response.status_code == 302
assert reverse("misago:admin:users:index") in response["location"]
| 2,951
|
Python
|
.py
| 71
| 36.323944
| 80
| 0.702143
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,374
|
signals.py
|
rafalp_Misago/misago/readtracker/signals.py
|
from django.dispatch import Signal, receiver
from ..categories.signals import delete_category_content, move_category_content
from ..threads.signals import merge_thread, move_thread
thread_read = Signal()
@receiver(delete_category_content)
def delete_category_threads(sender, **kwargs):
sender.readthread_set.all().delete()
sender.readcategory_set.all().delete()
@receiver(move_category_content)
def move_category_tracker(sender, **kwargs):
sender.readthread_set.update(category=kwargs["new_category"])
sender.readcategory_set.update(category=kwargs["new_category"])
@receiver(merge_thread)
def merge_thread_tracker(sender, **kwargs):
other_thread = kwargs["other_thread"]
other_thread.readthread_set.all().delete()
@receiver(move_thread)
def move_thread_tracker(sender, **kwargs):
sender.readthread_set.update(category=sender.category, thread=sender)
| 889
|
Python
|
.py
| 19
| 43.789474
| 79
| 0.783721
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,375
|
models.py
|
rafalp_Misago/misago/readtracker/models.py
|
from django.conf import settings
from django.db import models
from django.utils import timezone
class ReadCategory(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
read_time = models.DateTimeField(default=timezone.now)
class Meta:
constraints = [
models.UniqueConstraint(
fields=["user", "category"], name="uniq_user_category"
),
]
class ReadThread(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
category = models.ForeignKey("misago_categories.Category", on_delete=models.CASCADE)
thread = models.ForeignKey("misago_threads.Thread", on_delete=models.CASCADE)
read_time = models.DateTimeField(default=timezone.now)
class Meta:
constraints = [
models.UniqueConstraint(fields=["user", "thread"], name="uniq_user_thread"),
]
| 1,020
|
Python
|
.py
| 22
| 39.636364
| 88
| 0.710685
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,376
|
privatethreads.py
|
rafalp_Misago/misago/readtracker/privatethreads.py
|
from datetime import datetime
from django.http import HttpRequest
from django.db.models import F, Q
from ..categories.models import Category
from ..permissions.privatethreads import filter_private_threads_queryset
from .readtime import get_default_read_time
from .tracker import annotate_threads_read_time
def unread_private_threads_exist(
request: HttpRequest,
category: Category,
category_read_time: datetime | None,
) -> bool:
queryset = get_unread_private_threads(request, category, category_read_time)
return queryset.exists()
def get_unread_private_threads(
request: HttpRequest,
category: Category,
category_read_time: datetime | None,
):
read_time = get_default_read_time(request.settings, request.user)
if category_read_time:
read_time = max(read_time, category_read_time)
return (
filter_private_threads_queryset(
request.user_permissions,
annotate_threads_read_time(
request.user, category.thread_set, with_category=False
),
)
.filter(last_post_on__gt=read_time)
.filter(Q(last_post_on__gt=F("read_time")) | Q(read_time__isnull=True))
)
| 1,196
|
Python
|
.py
| 32
| 31.75
| 80
| 0.711073
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,377
|
apps.py
|
rafalp_Misago/misago/readtracker/apps.py
|
from django.apps import AppConfig
class MisagoReadTrackerConfig(AppConfig):
name = "misago.readtracker"
label = "misago_readtracker"
verbose_name = "Misago Read Tracker"
def ready(self):
from . import signals as _
| 241
|
Python
|
.py
| 7
| 29.571429
| 41
| 0.727273
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,378
|
threads.py
|
rafalp_Misago/misago/readtracker/threads.py
|
from datetime import datetime
from django.http import HttpRequest
from django.db.models import F, Q
from ..categories.models import Category
from ..permissions.threads import filter_category_threads_queryset
from ..threads.models import Thread
from .readtime import get_default_read_time
from .tracker import annotate_threads_read_time
def is_category_read(
request: HttpRequest, category: Category, category_read_time: datetime | None
) -> bool:
read_time = get_default_read_time(request.settings, request.user)
if category_read_time:
read_time = max(read_time, category_read_time)
queryset = (
filter_category_threads_queryset(
request.user_permissions,
request.categories.categories[category.id],
annotate_threads_read_time(
request.user, Thread.objects, with_category=False
),
)
.filter(last_post_on__gt=read_time)
.filter(Q(last_post_on__gt=F("read_time")) | Q(read_time__isnull=True))
)
return not queryset.exists()
| 1,057
|
Python
|
.py
| 26
| 34.461538
| 81
| 0.706055
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,379
|
tracker.py
|
rafalp_Misago/misago/readtracker/tracker.py
|
from datetime import datetime
from typing import TYPE_CHECKING, Iterable
from django.http import HttpRequest
from django.db.models import OuterRef
from ..categories.models import Category
from ..threads.models import Post, Thread
from .readtime import get_default_read_time
from .models import ReadCategory, ReadThread
if TYPE_CHECKING:
from ..users.models import User
def annotate_categories_read_time(user, queryset):
if user.is_anonymous:
return queryset
return queryset.annotate(
read_time=ReadCategory.objects.filter(
user=user,
category=OuterRef("id"),
).values("read_time"),
)
def get_unread_categories(
request: HttpRequest, categories: Iterable[Category]
) -> set[int]:
if not categories or request.user.is_anonymous:
return set()
default_read_time = get_default_read_time(request.settings, request.user)
unread_categories: set[int] = set()
for category in categories:
if is_category_unread(category, default_read_time):
unread_categories.add(category.id)
return unread_categories
def is_category_unread(
category: Category,
default_read_time: datetime,
) -> bool:
if not category.last_post_on:
return False
if category.last_post_on < default_read_time:
return False
if not category.read_time:
return True
return category.last_post_on > category.read_time
def annotate_threads_read_time(user, queryset, *, with_category: bool = True):
if user.is_anonymous:
return queryset
queryset = queryset.annotate(
read_time=ReadThread.objects.filter(
user=user,
thread=OuterRef("id"),
).values("read_time"),
)
if with_category:
queryset = queryset.annotate(
category_read_time=ReadCategory.objects.filter(
user=user,
category=OuterRef("category_id"),
).values("read_time"),
)
return queryset
def get_unread_threads(request: HttpRequest, threads: Iterable[Thread]) -> set[int]:
if not threads or request.user.is_anonymous:
return set()
default_read_time = get_default_read_time(request.settings, request.user)
unread_threads: set[int] = set()
for thread in threads:
if is_thread_unread(thread, default_read_time):
unread_threads.add(thread.id)
return unread_threads
def is_thread_unread(
thread: Thread,
default_read_time: datetime,
) -> bool:
if not thread.last_post_on:
return False
if thread.last_post_on < default_read_time:
return False
if thread.category_read_time and thread.last_post_on <= thread.category_read_time:
return False
if not thread.read_time:
return True
return thread.last_post_on > thread.read_time
def get_unread_posts(
request: HttpRequest,
thread: Thread,
posts: Iterable[Post],
) -> set[int]:
if not posts or request.user.is_anonymous:
return set()
read_time = get_thread_read_time(request, thread)
read_data: set[int] = set()
for post in posts:
if post.posted_on > read_time:
read_data.add(post.id)
return read_data
def get_thread_read_time(request: HttpRequest, thread: Thread) -> datetime:
default_read_time = get_default_read_time(request.settings, request.user)
if thread.read_time and thread.category_read_time:
read_time = max(thread.read_time, thread.category_read_time)
elif thread.read_time:
read_time = thread.read_time
elif thread.category_read_time:
read_time = thread.category_read_time
else:
read_time = default_read_time
return max(read_time, default_read_time)
def mark_thread_read(user: "User", thread: Thread, read_time: datetime):
create_row = True
if getattr(thread, "read_time", None):
create_row = not ReadThread.objects.filter(
user=user,
thread=thread,
).update(read_time=read_time)
if create_row:
ReadThread.objects.create(
user=user,
thread=thread,
category=thread.category,
read_time=read_time,
)
def mark_category_read(user: "User", category: Category, *, force_update: bool = False):
create_row = True
if force_update or getattr(category, "read_time", None):
create_row = not ReadCategory.objects.filter(
user=user,
category=category,
).update(read_time=category.last_post_on)
if create_row:
ReadCategory.objects.create(
user=user,
category=category,
read_time=category.last_post_on,
)
ReadThread.objects.filter(user=user, category=category).delete()
| 4,806
|
Python
|
.py
| 132
| 29.333333
| 88
| 0.669334
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,380
|
readtime.py
|
rafalp_Misago/misago/readtracker/readtime.py
|
from datetime import datetime, timedelta
from typing import TYPE_CHECKING, Optional
from django.utils import timezone
from ..conf.dynamicsettings import DynamicSettings
if TYPE_CHECKING:
from ..users.models import User
def get_default_read_time(
settings: DynamicSettings,
user: Optional["User"] = None,
) -> datetime:
min_read_time = timezone.now() - timedelta(days=settings.readtracker_cutoff)
if user and user.is_authenticated and user.joined_on > min_read_time:
return user.joined_on
return min_read_time
| 548
|
Python
|
.py
| 14
| 35.357143
| 80
| 0.766603
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,381
|
0002_postread.py
|
rafalp_Misago/misago/readtracker/migrations/0002_postread.py
|
# Generated by Django 1.11.5 on 2017-10-07 14:32
import django.db.models.deletion
import django.utils.timezone
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("misago_categories", "0006_moderation_queue_roles"),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
("misago_threads", "0006_redo_partial_indexes"),
("misago_readtracker", "0001_initial"),
]
operations = [
migrations.CreateModel(
name="PostRead",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"last_read_on",
models.DateTimeField(default=django.utils.timezone.now),
),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"post",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Post",
),
),
(
"thread",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Thread",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
)
]
| 2,065
|
Python
|
.py
| 60
| 18.033333
| 76
| 0.425075
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,382
|
0003_migrate_reads_to_posts.py
|
rafalp_Misago/misago/readtracker/migrations/0003_migrate_reads_to_posts.py
|
# Generated by Django 1.11.5 on 2017-10-07 14:49
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_readtracker", "0002_postread")]
operations = []
| 205
|
Python
|
.py
| 5
| 37.8
| 60
| 0.746193
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,383
|
0001_initial.py
|
rafalp_Misago/misago/readtracker/migrations/0001_initial.py
|
import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
("misago_threads", "0001_initial"),
]
operations = [
migrations.CreateModel(
name="CategoryRead",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("last_read_on", models.DateTimeField()),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
options={},
bases=(models.Model,),
),
migrations.CreateModel(
name="ThreadRead",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("last_read_on", models.DateTimeField()),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.Category",
),
),
(
"thread",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.Thread",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
options={},
bases=(models.Model,),
),
]
| 2,636
|
Python
|
.py
| 80
| 15.7
| 68
| 0.383229
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,384
|
0005_new_tracker.py
|
rafalp_Misago/misago/readtracker/migrations/0005_new_tracker.py
|
# Generated by Django 4.2.10 on 2024-08-27 16:36
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
("misago_threads", "0014_plugin_data"),
("misago_categories", "0013_new_behaviors"),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
("misago_readtracker", "0004_auto_20171015_2010"),
]
operations = [
migrations.CreateModel(
name="ReadCategory",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("read_time", models.DateTimeField(default=django.utils.timezone.now)),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.category",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
),
migrations.CreateModel(
name="ReadThread",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("read_time", models.DateTimeField(default=django.utils.timezone.now)),
(
"category",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_categories.category",
),
),
(
"thread",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to="misago_threads.thread",
),
),
(
"user",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL,
),
),
],
),
migrations.DeleteModel(
name="PostRead",
),
migrations.AddConstraint(
model_name="readthread",
constraint=models.UniqueConstraint(
fields=("user", "thread"), name="uniq_user_thread"
),
),
migrations.AddConstraint(
model_name="readcategory",
constraint=models.UniqueConstraint(
fields=("user", "category"), name="uniq_user_category"
),
),
]
| 3,256
|
Python
|
.py
| 94
| 18.43617
| 87
| 0.431422
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,385
|
0004_auto_20171015_2010.py
|
rafalp_Misago/misago/readtracker/migrations/0004_auto_20171015_2010.py
|
# Generated by Django 1.11.5 on 2017-10-15 20:10
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("misago_readtracker", "0003_migrate_reads_to_posts")]
operations = [
migrations.RemoveField(model_name="categoryread", name="category"),
migrations.RemoveField(model_name="categoryread", name="user"),
migrations.RemoveField(model_name="threadread", name="category"),
migrations.RemoveField(model_name="threadread", name="thread"),
migrations.RemoveField(model_name="threadread", name="user"),
migrations.DeleteModel(name="CategoryRead"),
migrations.DeleteModel(name="ThreadRead"),
]
| 692
|
Python
|
.py
| 13
| 46.769231
| 75
| 0.715976
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,386
|
conftest.py
|
rafalp_Misago/misago/readtracker/tests/conftest.py
|
from unittest.mock import Mock
import pytest
@pytest.fixture
def read_thread(user, thread):
save_read(user, thread.first_post)
return thread
@pytest.fixture
def anonymous_request_mock(dynamic_settings, anonymous_user, anonymous_user_acl):
return Mock(
settings=dynamic_settings, user=anonymous_user, user_acl=anonymous_user_acl
)
@pytest.fixture
def request_mock(dynamic_settings, user, user_acl):
return Mock(settings=dynamic_settings, user=user, user_acl=user_acl)
| 502
|
Python
|
.py
| 14
| 32.357143
| 83
| 0.777547
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,387
|
test_get_unread_posts.py
|
rafalp_Misago/misago/readtracker/tests/test_get_unread_posts.py
|
from datetime import timedelta
from unittest.mock import Mock
from django.utils import timezone
from ..models import ReadCategory, ReadThread
from ..tracker import annotate_threads_read_time, get_unread_posts
def test_get_unread_posts_returns_empty_set_for_anonymous_user(
dynamic_settings, default_category, thread, post, anonymous_user
):
request = Mock(settings=dynamic_settings, user=anonymous_user)
queryset = annotate_threads_read_time(anonymous_user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [post])
assert not unread_posts
def test_get_unread_posts_includes_unread_post(
dynamic_settings, default_category, thread, post, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [post])
assert post.id in unread_posts
def test_get_unread_posts_excludes_unread_post_older_than_user(
dynamic_settings, default_category, thread, post, user
):
post.posted_on -= timedelta(minutes=30)
post.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [post])
assert not unread_posts
def test_get_unread_posts_excludes_old_unread_post(
dynamic_settings, default_category, thread, post, user
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
post.posted_on = post.posted_on.replace(year=2012)
post.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [post])
assert not unread_posts
def test_get_unread_posts_excludes_read_post(
dynamic_settings, default_category, thread, post, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=timezone.now(),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [post])
assert not unread_posts
def test_get_unread_posts_excludes_unread_post_in_read_category(
dynamic_settings, default_category, thread, post, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now(),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [post])
assert not unread_posts
def test_get_unread_posts_includes_read_thread_unread_reply(
dynamic_settings, default_category, thread, post, reply, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
post.posted_on = timezone.now() - timedelta(minutes=10)
post.save()
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=timezone.now() - timedelta(minutes=5),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [reply])
assert post.id not in unread_posts
assert reply.id in unread_posts
def test_get_unread_posts_includes_read_thread_in_read_category_with_unread_reply(
dynamic_settings, default_category, thread, post, reply, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
post.posted_on = timezone.now() - timedelta(minutes=10)
post.save()
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now() - timedelta(minutes=5),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_posts = get_unread_posts(request, queryset.first(), [reply])
assert post.id not in unread_posts
assert reply.id in unread_posts
| 4,489
|
Python
|
.py
| 105
| 37.638095
| 86
| 0.728591
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,388
|
test_unread_private_threads_exist.py
|
rafalp_Misago/misago/readtracker/tests/test_unread_private_threads_exist.py
|
from datetime import timedelta
from unittest.mock import Mock
from django.utils import timezone
from ...categories.proxy import CategoriesProxy
from ...permissions.proxy import UserPermissionsProxy
from ...threads.models import ThreadParticipant
from ...threads.test import post_thread
from ..models import ReadThread
from ..privatethreads import unread_private_threads_exist
def test_unread_private_threads_exist_returns_true_for_unread_thread(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert unread_private_threads_exist(request, private_threads_category, None)
def test_unread_private_threads_exist_returns_false_for_read_thread(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
ReadThread.objects.create(
user=user,
category=private_threads_category,
thread=thread,
read_time=thread.last_post_on,
)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not unread_private_threads_exist(request, private_threads_category, None)
def test_unread_private_threads_exist_returns_false_for_thread_in_read_category(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not unread_private_threads_exist(
request, private_threads_category, timezone.now()
)
| 2,901
|
Python
|
.py
| 68
| 37.235294
| 84
| 0.753201
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,389
|
test_annotate_threads_read_time.py
|
rafalp_Misago/misago/readtracker/tests/test_annotate_threads_read_time.py
|
from django.utils import timezone
from ...threads.models import Thread
from ..models import ReadCategory, ReadThread
from ..tracker import annotate_threads_read_time
def test_annotate_threads_read_time_is_noop_for_anonymous_user(anonymous_user, thread):
queryset = annotate_threads_read_time(anonymous_user, Thread.objects.all())
thread = queryset.get(id=thread.id)
assert not hasattr(thread, "read_time")
assert not hasattr(thread, "category_read_time")
def test_annotate_threads_read_time_sets_none_read_time_for_user_without_one(
user, thread
):
queryset = annotate_threads_read_time(user, Thread.objects.all())
thread = queryset.get(id=thread.id)
assert thread.read_time is None
def test_annotate_threads_read_time_sets_read_time_for_user_with_one(user, thread):
read_time = timezone.now().replace(year=2012)
ReadThread.objects.create(
user=user,
category=thread.category,
thread=thread,
read_time=read_time,
)
queryset = annotate_threads_read_time(user, Thread.objects.all())
thread = queryset.get(id=thread.id)
assert thread.read_time == read_time
def test_annotate_threads_read_time_sets_none_category_read_time_for_user_without_one(
user, thread
):
queryset = annotate_threads_read_time(user, Thread.objects.all())
thread = queryset.get(id=thread.id)
assert thread.category_read_time is None
def test_annotate_threads_read_time_sets_category_read_time_for_user_with_one(
user, thread
):
read_time = timezone.now().replace(year=2012)
ReadCategory.objects.create(
user=user,
category=thread.category,
read_time=read_time,
)
queryset = annotate_threads_read_time(user, Thread.objects.all())
thread = queryset.get(id=thread.id)
assert thread.category_read_time == read_time
| 1,854
|
Python
|
.py
| 44
| 37.136364
| 87
| 0.732961
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,390
|
test_get_unread_categories.py
|
rafalp_Misago/misago/readtracker/tests/test_get_unread_categories.py
|
from datetime import timedelta
from unittest.mock import Mock
from django.utils import timezone
from ...categories.models import Category
from ..models import ReadCategory
from ..tracker import annotate_categories_read_time, get_unread_categories
def test_get_unread_categories_returns_empty_set_for_anonymous_user(
dynamic_settings, default_category, anonymous_user
):
default_category.last_post_on = timezone.now()
default_category.save()
request = Mock(settings=dynamic_settings, user=anonymous_user)
queryset = annotate_categories_read_time(anonymous_user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert not unread_categories
def test_get_unread_categories_excludes_unread_empty_category(dynamic_settings, user):
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert not unread_categories
def test_get_unread_categories_includes_unread_category_with_last_post(
dynamic_settings, default_category, user
):
default_category.last_post_on = timezone.now()
default_category.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert default_category.id in unread_categories
def test_get_unread_categories_excludes_read_empty_category(
dynamic_settings, default_category, user
):
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now(),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert not unread_categories
def test_get_unread_categories_includes_read_category_with_new_last_post(
dynamic_settings, default_category, user
):
user.joined_on -= timedelta(days=2)
user.save()
default_category.last_post_on = timezone.now()
default_category.save()
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now() - timedelta(minutes=5),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert default_category.id in unread_categories
def test_get_unread_categories_excludes_read_category(
dynamic_settings, default_category, user
):
user.joined_on -= timedelta(days=2)
user.save()
default_category.last_post_on = timezone.now()
default_category.save()
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=default_category.last_post_on,
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert default_category.id not in unread_categories
def test_get_unread_categories_excludes_unread_category_with_last_post_older_than_user(
dynamic_settings, default_category, user
):
user.joined_on -= timedelta(days=2)
user.save()
default_category.last_post_on = timezone.now() - timedelta(days=3)
default_category.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert not unread_categories
def test_get_unread_categories_excludes_unread_category_with_last_post_older_than_cutoff(
dynamic_settings, default_category, user
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
default_category.last_post_on = timezone.now().replace(year=2012)
default_category.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert not unread_categories
def test_get_unread_categories_excludes_read_category_with_last_post_older_than_cutoff(
dynamic_settings, default_category, user
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
default_category.last_post_on = timezone.now().replace(year=2012)
default_category.save()
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now().replace(year=2011),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_categories_read_time(user, Category.objects.all())
unread_categories = get_unread_categories(request, queryset)
assert not unread_categories
| 5,007
|
Python
|
.py
| 111
| 40.099099
| 89
| 0.752834
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,391
|
test_get_unread_threads.py
|
rafalp_Misago/misago/readtracker/tests/test_get_unread_threads.py
|
from datetime import timedelta
from unittest.mock import Mock
from django.utils import timezone
from ..models import ReadCategory, ReadThread
from ..tracker import annotate_threads_read_time, get_unread_threads
def test_get_unread_threads_returns_empty_set_for_anonymous_user(
dynamic_settings, default_category, thread, anonymous_user
):
request = Mock(settings=dynamic_settings, user=anonymous_user)
queryset = annotate_threads_read_time(anonymous_user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert not unread_threads
def test_get_unread_threads_includes_unread_thread(
dynamic_settings, default_category, thread, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert thread.id in unread_threads
def test_get_unread_threads_excludes_unread_thread_older_than_user(
dynamic_settings, default_category, thread, user
):
thread.last_post_on -= timedelta(minutes=30)
thread.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert not unread_threads
def test_get_unread_threads_excludes_old_unread_thread(
dynamic_settings, default_category, thread, user
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread.last_post_on = thread.last_post_on.replace(year=2012)
thread.save()
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert not unread_threads
def test_get_unread_threads_excludes_read_thread(
dynamic_settings, default_category, thread, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=timezone.now(),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert not unread_threads
def test_get_unread_threads_excludes_unread_thread_in_read_category(
dynamic_settings, default_category, thread, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=thread.last_post_on,
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert not unread_threads
def test_get_unread_threads_includes_read_thread_with_unread_reply(
dynamic_settings, default_category, thread, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=timezone.now() - timedelta(minutes=5),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert thread.id in unread_threads
def test_get_unread_threads_includes_read_thread_in_read_category_with_unread_reply(
dynamic_settings, default_category, thread, user
):
user.joined_on -= timedelta(minutes=30)
user.save()
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now() - timedelta(minutes=5),
)
request = Mock(settings=dynamic_settings, user=user)
queryset = annotate_threads_read_time(user, default_category.thread_set)
unread_threads = get_unread_threads(request, queryset.all())
assert thread.id in unread_threads
| 4,222
|
Python
|
.py
| 99
| 37.545455
| 86
| 0.740269
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,392
|
test_min_read_time.py
|
rafalp_Misago/misago/readtracker/tests/test_min_read_time.py
|
from datetime import timedelta
from unittest.mock import Mock
from django.utils import timezone
from ...conf.test import override_dynamic_settings
from ..readtime import get_default_read_time
def test_default_read_time_for_empty_user_is_relative_to_current_time(dynamic_settings):
default_read_time = get_default_read_time(dynamic_settings)
valid_default_read_time = timezone.now() - timedelta(
days=dynamic_settings.readtracker_cutoff
)
assert (valid_default_read_time - default_read_time).seconds < 1
def test_default_read_time_for_anonymous_user_is_relative_to_current_time(
dynamic_settings, anonymous_user
):
default_read_time = get_default_read_time(dynamic_settings, anonymous_user)
valid_default_read_time = timezone.now() - timedelta(
days=dynamic_settings.readtracker_cutoff
)
assert (valid_default_read_time - default_read_time).seconds < 1
def test_default_read_time_for_recently_registered_user_is_their_registration_date(
dynamic_settings, user
):
user = Mock(is_authenticated=True, joined_on=timezone.now())
default_read_time = get_default_read_time(dynamic_settings, user)
assert default_read_time == user.joined_on
@override_dynamic_settings(readtracker_cutoff=5)
def test_default_read_time_for_old_user_is_relative_to_current_time(dynamic_settings):
user = Mock(is_authenticated=True, joined_on=timezone.now() - timedelta(days=6))
default_read_time = get_default_read_time(dynamic_settings, user)
valid_default_read_time = timezone.now() - timedelta(
days=dynamic_settings.readtracker_cutoff
)
assert (valid_default_read_time - default_read_time).seconds < 1
assert default_read_time > user.joined_on
| 1,729
|
Python
|
.py
| 34
| 46.617647
| 88
| 0.759644
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,393
|
test_is_category_read.py
|
rafalp_Misago/misago/readtracker/tests/test_is_category_read.py
|
from datetime import timedelta
from unittest.mock import Mock
from django.utils import timezone
from ...categories.proxy import CategoriesProxy
from ...permissions.proxy import UserPermissionsProxy
from ...threads.test import post_thread
from ..models import ReadThread
from ..threads import is_category_read
def test_is_category_read_returns_true_for_empty_category(
dynamic_settings, cache_versions, user, default_category
):
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert is_category_read(request, default_category, None)
def test_is_category_read_returns_false_for_category_with_unread_thread(
dynamic_settings, cache_versions, user, default_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(default_category)
default_category.last_post_on = thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not is_category_read(request, default_category, None)
def test_is_category_read_returns_true_for_category_with_old_unread_thread(
dynamic_settings, cache_versions, user, default_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(default_category, started_on=timezone.now().replace(year=2012))
default_category.last_post_on = thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert is_category_read(request, default_category, None)
def test_is_category_read_returns_true_for_category_with_unread_thread_older_than_user(
dynamic_settings, cache_versions, user, default_category
):
thread = post_thread(
default_category, started_on=timezone.now() - timedelta(minutes=30)
)
default_category.last_post_on = thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert is_category_read(request, default_category, None)
def test_is_category_read_returns_true_for_category_with_read_thread(
dynamic_settings, cache_versions, user, default_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(default_category)
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=thread.last_post_on,
)
default_category.last_post_on = thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert is_category_read(request, default_category, None)
def test_is_category_read_returns_false_for_category_with_one_read_and_one_unread_thread(
dynamic_settings, cache_versions, user, default_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(default_category)
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=thread.last_post_on,
)
unread_thread = post_thread(default_category)
default_category.last_post_on = unread_thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not is_category_read(request, default_category, None)
def test_is_category_read_returns_true_for_category_with_one_read_and_one_invisible_unread_thread(
dynamic_settings, cache_versions, user, default_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(default_category)
ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=thread.last_post_on,
)
post_thread(default_category, is_hidden=True)
default_category.last_post_on = thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert is_category_read(request, default_category, None)
def test_is_category_read_returns_true_for_read_category_with_both_read_threads(
dynamic_settings, cache_versions, user, default_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
old_thread = post_thread(
default_category, started_on=timezone.now() - timedelta(minutes=30)
)
recent_thread = post_thread(default_category)
default_category.last_post_on = recent_thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert is_category_read(request, default_category, timezone.now())
def test_is_category_read_returns_false_for_read_category_with_one_read_and_one_unread_thread(
dynamic_settings, cache_versions, user, default_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(
default_category, started_on=timezone.now() - timedelta(minutes=30)
)
unread_thread = post_thread(default_category)
default_category.last_post_on = unread_thread.last_post_on
default_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not is_category_read(
request, default_category, timezone.now() - timedelta(minutes=15)
)
| 7,061
|
Python
|
.py
| 175
| 34.428571
| 98
| 0.727486
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,394
|
test_mark_category_read.py
|
rafalp_Misago/misago/readtracker/tests/test_mark_category_read.py
|
from datetime import timedelta
from django.utils import timezone
from ..models import ReadCategory, ReadThread
from ..tracker import mark_category_read
def test_mark_category_read_creates_read_category(user, default_category):
default_category.last_post_on = timezone.now()
default_category.save()
mark_category_read(user, default_category)
ReadCategory.objects.get(
user=user,
category=default_category,
read_time=default_category.last_post_on,
)
def test_mark_category_read_updates_read_category_for_category_with_read_time(
user, default_category
):
read_time = timezone.now()
old_read_time = read_time - timedelta(hours=24 * 5)
read_category = ReadCategory.objects.create(
user=user,
category=default_category,
read_time=old_read_time,
)
default_category.last_post_on = read_time
default_category.save()
default_category.read_time = old_read_time
mark_category_read(user, default_category)
read_category.refresh_from_db()
assert read_category.read_time == read_time
def test_mark_category_read_creates_missing_read_category_for_category_with_read_time(
user, default_category
):
read_time = timezone.now()
old_read_time = read_time - timedelta(hours=24 * 5)
default_category.last_post_on = read_time
default_category.save()
default_category.read_time = old_read_time
mark_category_read(user, default_category)
ReadCategory.objects.get(
user=user,
category=default_category,
read_time=read_time,
)
def test_mark_category_read_creates_missing_read_category_for_category_without_read_time(
user, default_category
):
read_time = timezone.now()
default_category.last_post_on = read_time
default_category.save()
default_category.read_time = None
mark_category_read(user, default_category)
ReadCategory.objects.get(
user=user,
category=default_category,
read_time=read_time,
)
def test_mark_category_read_creates_missing_read_category_for_category_in_forced_update(
user, default_category
):
read_time = timezone.now()
default_category.last_post_on = read_time
default_category.save()
mark_category_read(user, default_category, force_update=True)
ReadCategory.objects.get(
user=user,
category=default_category,
read_time=read_time,
)
| 2,441
|
Python
|
.py
| 68
| 30.338235
| 89
| 0.719163
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,395
|
test_clearreadtracker_command.py
|
rafalp_Misago/misago/readtracker/tests/test_clearreadtracker_command.py
|
from datetime import timedelta
from io import StringIO
import pytest
from django.core import management
from django.utils import timezone
from ...conf.test import override_dynamic_settings
from ..management.commands import clearreadtracker
from ..models import ReadCategory, ReadThread
def call_command() -> list[str]:
command = clearreadtracker.Command()
out = StringIO()
management.call_command(command, stdout=out)
return [l.strip() for l in out.getvalue().strip().splitlines()]
def test_command_works_if_there_are_no_read_tracker_times(db):
assert call_command() == [
"Expired read times deleted:",
"- Categories: 0",
"- Threads: 0",
"",
"Remaining:",
"- Categories: 0",
"- Threads: 0",
]
@override_dynamic_settings(readtracker_cutoff=5)
def test_recent_category_read_time_is_not_cleared(user, default_category):
read_time = ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now(),
)
assert call_command() == [
"Expired read times deleted:",
"- Categories: 0",
"- Threads: 0",
"",
"Remaining:",
"- Categories: 1",
"- Threads: 0",
]
read_time.refresh_from_db()
@override_dynamic_settings(readtracker_cutoff=5)
def test_old_category_read_time_is_cleared(user, default_category):
read_time = ReadCategory.objects.create(
user=user,
category=default_category,
read_time=timezone.now() - timedelta(days=10),
)
assert call_command() == [
"Expired read times deleted:",
"- Categories: 1",
"- Threads: 0",
"",
"Remaining:",
"- Categories: 0",
"- Threads: 0",
]
with pytest.raises(ReadCategory.DoesNotExist):
read_time.refresh_from_db()
@override_dynamic_settings(readtracker_cutoff=5)
def test_recent_thread_read_time_is_not_cleared(user, default_category, thread):
read_time = ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=timezone.now(),
)
assert call_command() == [
"Expired read times deleted:",
"- Categories: 0",
"- Threads: 0",
"",
"Remaining:",
"- Categories: 0",
"- Threads: 1",
]
read_time.refresh_from_db()
@override_dynamic_settings(readtracker_cutoff=5)
def test_old_thread_read_time_is_cleared(user, default_category, thread):
read_time = ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=timezone.now() - timedelta(days=10),
)
assert call_command() == [
"Expired read times deleted:",
"- Categories: 0",
"- Threads: 1",
"",
"Remaining:",
"- Categories: 0",
"- Threads: 0",
]
with pytest.raises(ReadThread.DoesNotExist):
read_time.refresh_from_db()
| 3,084
|
Python
|
.py
| 95
| 25.831579
| 80
| 0.610924
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,396
|
test_annotate_categories_read_time.py
|
rafalp_Misago/misago/readtracker/tests/test_annotate_categories_read_time.py
|
from django.utils import timezone
from ...categories.models import Category
from ..models import ReadCategory
from ..tracker import annotate_categories_read_time
def test_annotate_categories_read_time_is_noop_for_anonymous_user(db, anonymous_user):
queryset = annotate_categories_read_time(anonymous_user, Category.objects.all())
category = queryset.get(slug="first-category")
assert not hasattr(category, "read_time")
def test_annotate_categories_read_time_sets_none_read_time_for_user_without_one(user):
queryset = annotate_categories_read_time(user, Category.objects.all())
category = queryset.get(slug="first-category")
assert category.read_time is None
def test_annotate_categories_read_time_sets_read_time_for_user_with_one(
user, default_category
):
read_time = timezone.now().replace(year=2012)
ReadCategory.objects.create(
user=user,
category=default_category,
read_time=read_time,
)
queryset = annotate_categories_read_time(user, Category.objects.all())
category = queryset.get(slug="first-category")
assert category.read_time == read_time
| 1,138
|
Python
|
.py
| 24
| 42.75
| 86
| 0.755898
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,397
|
test_mark_thread_read.py
|
rafalp_Misago/misago/readtracker/tests/test_mark_thread_read.py
|
from datetime import timedelta
from django.utils import timezone
from ..models import ReadThread
from ..tracker import mark_thread_read
def test_mark_thread_read_creates_read_thread_for_thread_without_read_time(
user, default_category, thread
):
read_time = timezone.now()
thread.read_time = None
mark_thread_read(user, thread, read_time)
ReadThread.objects.get(
user=user,
category=default_category,
thread=thread,
read_time=read_time,
)
def test_mark_thread_read_updates_read_thread_for_thread_with_read_time(
user, default_category, thread
):
read_time = timezone.now()
old_read_time = read_time - timedelta(hours=24 * 5)
read_thread = ReadThread.objects.create(
user=user,
category=default_category,
thread=thread,
read_time=old_read_time,
)
thread.read_time = old_read_time
mark_thread_read(user, thread, read_time)
read_thread.refresh_from_db()
assert read_thread.read_time == read_time
def test_mark_thread_read_creates_missing_read_thread_for_thread_with_read_time(
user, default_category, thread
):
read_time = timezone.now()
old_read_time = read_time - timedelta(hours=24 * 5)
thread.read_time = old_read_time
mark_thread_read(user, thread, read_time)
ReadThread.objects.get(
user=user,
category=default_category,
thread=thread,
read_time=read_time,
)
| 1,461
|
Python
|
.py
| 44
| 27.681818
| 80
| 0.696148
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,398
|
test_get_unread_private_threads.py
|
rafalp_Misago/misago/readtracker/tests/test_get_unread_private_threads.py
|
from datetime import timedelta
from unittest.mock import Mock
from django.utils import timezone
from ...categories.proxy import CategoriesProxy
from ...permissions.proxy import UserPermissionsProxy
from ...threads.models import ThreadParticipant
from ...threads.test import post_thread, reply_thread
from ..models import ReadThread
from ..privatethreads import get_unread_private_threads
def test_get_unread_private_threads_returns_nothing_for_empty_category(
dynamic_settings, cache_versions, user, private_threads_category
):
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not get_unread_private_threads(request, private_threads_category, None)
def test_get_unread_private_threads_returns_unread_thread(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert list(
get_unread_private_threads(request, private_threads_category, None)
) == [thread]
def test_get_unread_private_threads_excludes_unread_thread_older_than_tracking_period(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(
private_threads_category, started_on=timezone.now().replace(year=2012)
)
ThreadParticipant.objects.create(user=user, thread=thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not get_unread_private_threads(request, private_threads_category, None)
def test_get_unread_private_threads_excludes_unread_thread_older_than_user(
dynamic_settings, cache_versions, user, private_threads_category
):
thread = post_thread(
private_threads_category, started_on=timezone.now() - timedelta(minutes=30)
)
ThreadParticipant.objects.create(user=user, thread=thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not get_unread_private_threads(request, private_threads_category, None)
def test_get_unread_private_threads_excludes_read_thread(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
ReadThread.objects.create(
user=user,
category=private_threads_category,
thread=thread,
read_time=thread.last_post_on,
)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not get_unread_private_threads(request, private_threads_category, None)
def test_get_unread_private_threads_includes_read_thread_with_unread_reply(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
ReadThread.objects.create(
user=user,
category=private_threads_category,
thread=thread,
read_time=thread.last_post_on,
)
reply_thread(thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert list(
get_unread_private_threads(request, private_threads_category, None)
) == [thread]
def test_get_unread_private_threads_excludes_thread_in_read_category(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not get_unread_private_threads(
request, private_threads_category, timezone.now()
)
def test_get_unread_private_threads_includes_thread_in_read_category_with_unread_reply(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
ThreadParticipant.objects.create(user=user, thread=thread)
reply = reply_thread(thread)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert list(
get_unread_private_threads(
request, private_threads_category, reply.posted_on - timedelta(minutes=1)
)
) == [thread]
def test_get_unread_private_threads_excludes_unread_thread_user_is_not_invited_to(
dynamic_settings, cache_versions, user, private_threads_category
):
user.joined_on = user.joined_on.replace(year=2010)
user.save()
thread = post_thread(private_threads_category)
private_threads_category.last_post_on = thread.last_post_on
private_threads_category.save()
user_permissions = UserPermissionsProxy(user, cache_versions)
request = Mock(
categories=CategoriesProxy(user_permissions, cache_versions),
settings=dynamic_settings,
user=user,
user_permissions=user_permissions,
)
assert not get_unread_private_threads(request, private_threads_category, None)
| 7,654
|
Python
|
.py
| 181
| 36.403315
| 87
| 0.738439
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|
18,399
|
clearreadtracker.py
|
rafalp_Misago/misago/readtracker/management/commands/clearreadtracker.py
|
from django.core.management.base import BaseCommand
from ....conf.shortcuts import get_dynamic_settings
from ...readtime import get_default_read_time
from ...models import ReadCategory, ReadThread
class Command(BaseCommand):
help = "Deletes expired read times from the database"
def handle(self, *args, **options):
settings = get_dynamic_settings()
default_read_time = get_default_read_time(settings)
deleted_categories, _ = ReadCategory.objects.filter(
read_time__lte=default_read_time
).delete()
deleted_threads, _ = ReadThread.objects.filter(
read_time__lte=default_read_time
).delete()
self.stdout.write("Expired read times deleted:")
self.stdout.write(f" - Categories: {deleted_categories}")
self.stdout.write(f" - Threads: {deleted_threads}")
self.stdout.write("\nRemaining:")
self.stdout.write(f" - Categories: {ReadCategory.objects.count()}")
self.stdout.write(f" - Threads: {ReadThread.objects.count()}")
| 1,064
|
Python
|
.py
| 21
| 43.190476
| 77
| 0.67343
|
rafalp/Misago
| 2,519
| 524
| 136
|
GPL-2.0
|
9/5/2024, 5:12:22 PM (Europe/Amsterdam)
|