wbcore 1.59.9__py2.py3-none-any.whl

wbcore/test/tests.py

@@ -0,0 +1,129 @@
+import pytest
+from django.conf import settings
+from django.db import models
+
+from wbcore import serializers, viewsets
+from wbcore.contrib.pandas.views import PandasAPIViewSet
+
+from .mixins import (
+    TestChartViewSet,
+    TestModel,
+    TestPandasView,
+    TestRepresentationViewSet,
+    TestSerializer,
+    TestViewSet,
+)
+from .utils import get_all_subclasses, is_intermediate_table_m2m
+
+""""
+If CELERY_TASK_ALWAYS_EAGER is True, all tasks will be executed locally by blocking until the task returns.
+apply_async() and Task.delay() will return an EagerResult instance, that emulates the API and behavior of AsyncResult, except the result is already evaluated.
+That is, tasks will be executed locally instead of being sent to the queue.
+This is useful mainly when running tests, or running locally without Celery workers.
+"""
+settings.CELERY_TASK_ALWAYS_EAGER = True
+
+
+def modules_condition(module):
+    return not module.startswith(("wbcore", "django", "rest_framework", "dynamic_preferences", "eventtools")) or (
+        module.startswith("wbcore") and module.startswith("wbcore.contrib")
+    )
+
+
+default_config = {
+    "models": list(
+        filter(
+            lambda x: modules_condition(x.__module__) and not x._meta.abstract and not is_intermediate_table_m2m(x),
+            get_all_subclasses(models.Model),
+        )
+    ),
+    "serializers": list(
+        filter(lambda x: modules_condition(x.__module__), get_all_subclasses(serializers.ModelSerializer))
+    ),
+    "representations": list(
+        filter(lambda x: modules_condition(x.__module__), get_all_subclasses(viewsets.RepresentationViewSet))
+    ),
+    "viewsets": list(
+        filter(
+            lambda x: modules_condition(x.__module__) and x not in get_all_subclasses(viewsets.InfiniteDataModelView),
+            get_all_subclasses(viewsets.ModelViewSet),
+        )
+    ),
+    "pandasviews": list(
+        filter(
+            lambda x: modules_condition(x.__module__),
+            get_all_subclasses(PandasAPIViewSet),
+        )
+    ),
+    "chartviewsets": list(
+        filter(
+            lambda x: modules_condition(x.__module__),
+            get_all_subclasses(viewsets.ChartViewSet),
+        )
+    ),
+}
+
+
+class GenerateTest:
+    def __init__(self, config):
+        self.config = config
+
+    def test_models(self, _model):
+        my_test = TestModel(_model)
+        my_test.execute_test()
+
+    def test_serializers(self, _serializer):
+        my_test = TestSerializer(_serializer)
+        my_test.execute_test()
+
+    def test_representationviewsets(self, rvs):
+        my_test = TestRepresentationViewSet(rvs)
+        my_test.execute_test()
+
+    def test_modelviewsets(self, mvs, client):
+        my_test = TestViewSet(mvs)
+        my_test.execute_test_list_endpoint(client)
+        my_test.execute_test_detail_endpoint()
+
+    def test_pandasviews(self, pvs):
+        my_test = TestPandasView(pvs)
+        if my_test.model:
+            my_test.execute_test()
+
+    def test_chartviewsets(self, cvs):
+        my_test = TestChartViewSet(cvs)
+        my_test.execute_test()
+
+    def __call__(self, test_class):
+        @pytest.mark.parametrize("_model", self.config.get("models", []))
+        def _test_models(_self, _model):
+            self.test_models(_model)
+
+        @pytest.mark.parametrize("_serializer", self.config.get("serializers", []))
+        def _test_serializers(_self, _serializer):
+            self.test_serializers(_serializer)
+
+        @pytest.mark.parametrize("rvs", self.config.get("representations", []))
+        def _test_representationviewsets(_self, rvs):
+            self.test_representationviewsets(rvs)
+
+        @pytest.mark.parametrize("mvs", self.config.get("viewsets", []))
+        def _test_modelviewsets(_self, mvs, client):
+            self.test_modelviewsets(mvs, client)
+
+        @pytest.mark.parametrize("pvs", self.config.get("pandasviews", []))
+        def _test_pandasviews(_self, pvs):
+            self.test_pandasviews(pvs)
+
+        @pytest.mark.parametrize("cvs", self.config.get("chartviewsets", []))
+        def _test_chartviewsets(_self, cvs):
+            self.test_chartviewsets(cvs)
+
+        test_class.test_models = _test_models
+        test_class.test_serializers = _test_serializers
+        test_class.test_representationviewsets = _test_representationviewsets
+        test_class.test_modelviewsets = _test_modelviewsets
+        test_class.test_pandasviews = _test_pandasviews
+        test_class.test_chartviewsets = _test_chartviewsets
+
+        return test_class

wbcore/test/utils.py

@@ -0,0 +1,227 @@
+import datetime
+import json
+from contextlib import suppress
+from functools import partial
+from typing import Any, Dict
+
+import factory
+from django.db import models
+from django.forms.models import model_to_dict
+from factory import Factory
+from factory.base import StubObject
+from rest_framework.request import Request
+from rest_framework.test import APIRequestFactory
+
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.authentication.models import Token
+
+from .signals import (
+    custom_update_data_from_factory,
+    custom_update_kwargs,
+    get_custom_serializer,
+)
+
+
+def get_all_subclasses(klass):
+    for subclass in klass.__subclasses__():
+        yield subclass
+        yield from get_all_subclasses(subclass)
+
+
+def all_subclasses(cls):
+    return set(cls.__subclasses__()).union([s for c in cls.__subclasses__() for s in all_subclasses(c)])
+
+
+def get_model_factory(model):
+    # mf = [cls for cls in factory.django.DjangoModelFactory.__subclasses__() if cls._meta.model == model]
+    mfs = [cls for cls in all_subclasses(factory.django.DjangoModelFactory) if cls._meta.model == model]
+    if is_empty(mfs) or model is None:
+        return None
+    else:
+        mf = [mf for mf in mfs if (hasattr(mf, "__name__") and mf.__name__ == model.__name__ + "Factory")]
+        if not is_empty(mf):
+            return mf[0]
+        else:
+            return mfs[0]
+
+
+def get_data_from_factory(instance, viewset, delete=False, update=False, superuser=None, factory=None):  # noqa: C901
+    """
+    Our goal here is to get the serializer dynamically based on the viewset, use this serializer to generate data for the post and update test.
+    """
+    obj_factory = instance
+    if delete and factory:
+        instance = factory()
+    kwargs = getattr(viewset, "kwargs", {})
+    kwargs["pk"] = instance.pk
+    viewset.kwargs = kwargs
+    mvs = viewset()
+
+    request = APIRequestFactory().get("")
+    if superuser:
+        request.user = superuser
+        request.parser_context = {"view": mvs}
+        _request = request
+    else:
+        _request = Request(request)
+    mvs.request = request
+    """
+        TODO
+        request = mvs.initialize_request(request)
+        object has no attribute 'action_map'
+        action_map is filled according to the parameter given to as_view
+        Need to find better approch
+    """
+
+    if delete:
+        mvs.action = "create"
+    elif update:
+        mvs.action = "update"
+    else:
+        mvs.action = "list"
+    my_serializer = mvs.get_serializer_class()
+    if custom_serializer := get_custom_serializer.send(viewset):
+        my_serializer = custom_serializer[0][1]
+    my_model = my_serializer.Meta.model
+
+    # fields_models = [m.name for m in my_model._meta.get_fields()]
+    dict_fields_models = {}
+    for m in my_model._meta.get_fields():
+        dict_fields_models[m.name] = m
+    data = {}
+    for key, value in my_serializer(instance, context={"request": _request}).data.items():
+        if key in dict_fields_models.keys() and key != "frontend_settings" and key != "id":
+            if key == "auth_token":
+                data[key], _ = Token.objects.get_or_create(user=instance)
+            elif dict_fields_models[key].get_internal_type() in ["FileField", "ImageField"]:
+                """
+                # Create a sample test file on the fly
+                fpath = "testfile.txt"
+                f = open(fpath, "w")
+                f.write("Hello World")
+                f.close()
+                data[key] = open(fpath, "r")
+                data[key] = document.file.open(mode='rb')
+                """
+                pass  # data[key] = open(value.replace("http://testserver/",""), 'rb')
+            else:
+                data[key] = value
+            # Related objects with cascading on_delete will be deleted. we create a new related object and override the id of the deleted object
+            if delete and (_field := dict_fields_models[key]):
+                if (
+                    _field.is_relation
+                    and not _field.null
+                    and _field.many_to_one
+                    and (_related_fields := _field.related_fields)
+                ):
+                    with suppress(Exception):
+                        lh_field, rh_field = _related_fields[0]
+                        if isinstance(lh_field, models.fields.AutoField) or isinstance(
+                            rh_field, models.fields.AutoField
+                        ):
+                            data[key] = get_model_factory(dict_fields_models[key].related_model).id
+    if update or delete:
+        _kwargs = {"user": superuser, "obj_factory": obj_factory}
+        if delete:
+            _kwargs.update({"obj_pre_deleted": instance})
+        if custom_data := custom_update_data_from_factory.send(viewset, **_kwargs):
+            data.update(custom_data[0][1])
+    # delete object for create with post method
+    if delete:
+        my_model.objects.filter(pk=instance.pk).delete()
+    data = {k: v for k, v in data.items() if v is not None}  # Filter out keys with `None` values
+    return data
+
+
+def get_kwargs(instance, viewset, request, data=None):
+    """
+    Get the kwargs needed for a ViewSet, handling related fields
+    """
+    viewset.kwargs = {"pk": instance.pk}  # set kwargs attribute to viewset
+    kwargs = {"user": request.user, "profile": getattr(request.user, "profile", None), "obj_factory": instance}
+    if isinstance(data, str):
+        # Convert JSON string to dictionary if necessary
+        data = json.loads(data)
+    data = data or model_to_dict(instance)
+    # Add related field IDs to kwargs
+    for field in viewset.get_model()._meta.get_fields():
+        if field.is_relation and field.many_to_one and (related_field_id := data.get(field.name)):
+            kwargs[f"{field.name}_id"] = related_field_id
+
+    # Add custom kwargs, if any, from signal handler
+    if custom_kwargs := custom_update_kwargs.send(viewset, **kwargs):
+        kwargs.update(custom_kwargs[0][1])
+    return kwargs
+
+
+def generate_dict_factory(factory: Factory):
+    def convert_dict_from_stub(stub: StubObject) -> Dict[str, Any]:
+        stub_dict = stub.__dict__
+        for key, value in stub_dict.items():
+            if isinstance(value, StubObject):
+                stub_dict[key] = convert_dict_from_stub(value)
+        return stub_dict
+
+    def dict_factory(factory, **kwargs):
+        stub = factory.stub(**kwargs)
+        stub_dict = convert_dict_from_stub(stub)
+        return stub_dict
+
+    return partial(dict_factory, factory)
+
+
+# check if an element of a list is present in the other
+def contains(lst1, lst2):
+    return any(elt in lst1 for elt in lst2)
+
+
+def is_intermediate_table_m2m(model):
+    if "_" in model.__qualname__ and not is_empty(model._meta.unique_together):
+        list_models = [elt.lower() for elt in model.__qualname__.split("_")]
+        list_models_id = [elt.lower() + "_id" for elt in model.__qualname__.split("_")]
+        if (
+            contains(list_models, model._meta.unique_together[0])
+            and contains(list_models, model.__dict__.keys())
+            and contains(list_models_id, model.__dict__.keys())
+        ):
+            return True
+    return False
+
+
+def is_empty(any_structure):
+    if any_structure:
+        return False
+    else:
+        return True
+
+
+def get_factory_custom_user():
+    list_models = [
+        m
+        for m in get_all_subclasses(models.Model)
+        if m.__name__ == ("User")
+        and not m.__module__.startswith(("wbcore", "django", "rest_framework", "dynamic_preferences", "eventtools"))
+        and not m._meta.abstract
+        and not is_intermediate_table_m2m(m)
+    ]
+    userfactory = [
+        get_model_factory(modl) for modl in list(dict.fromkeys(list_models)) if get_model_factory(modl) is not None
+    ]
+    if not is_empty(userfactory):
+        return userfactory[0]
+    return None
+
+
+def format_number(number, is_pourcent=False, decimal=2):
+    number = number if number else 0
+    return f'{number:,.{decimal}{"%" if is_pourcent else "f"}}'
+
+
+# https://stackoverflow.com/questions/11875770/how-to-overcome-datetime-datetime-not-json-serializable?page=1&tab=votes#tab-top
+def datetime_converter(o):
+    if isinstance(o, (datetime.date, datetime.datetime, datetime.time)):
+        return o.isoformat()
+
+
+def get_or_create_superuser():
+    return UserFactory.create(is_active=True, is_superuser=True)

wbcore/tests/conftest.py

@@ -0,0 +1,55 @@
+from datetime import date
+
+import pytest
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from rest_framework.test import APIRequestFactory
+from wbcore.configs.registry import ConfigRegistry
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.geography.tests.conftest import *
+
+fake = Faker()
+
+
+def app_pre_migration(sender, app_config, **kwargs):
+    cur = connection.cursor()
+    cur.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")
+    cur.execute("CREATE EXTENSION IF NOT EXISTS btree_gin;")
+    cur.execute("CREATE EXTENSION IF NOT EXISTS btree_gist;")
+
+
+@pytest.fixture(autouse=True, scope="session")
+def django_test_environment(django_test_environment):
+    from django.apps import apps
+
+    get_models = apps.get_models
+
+    for m in [m for m in get_models() if not m._meta.managed]:
+        m._meta.managed = True
+
+
+@pytest.fixture()
+def super_user():
+    return UserFactory.create(is_superuser=True)
+
+
+@pytest.fixture()
+def weekday() -> date:
+    return (fake.date_object() - BDay(0)).date()
+
+
+pre_migrate.connect(app_pre_migration)
+
+
+@pytest.fixture()
+def config_registry():
+    request = APIRequestFactory().get("/")
+    registry = ConfigRegistry(request)
+    return registry
+
+
+@pytest.fixture
+def chrome_options(chrome_options):
+    # chrome_options.add_argument("--headless=new")
+    chrome_options.add_argument("--disable-extensions")
+    return chrome_options

wbcore/tests/e2e/test_e2e.py

@@ -0,0 +1,25 @@
+import pytest
+
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.authentication.models import User
+from wbcore.test import find_element, login
+
+USER_PASSWORD = "User_Password"
+
+
+@pytest.mark.skip(reason="no way of currently testing this")
+@pytest.mark.django_db
+class TestE2ELogin:
+    def test_login_success(self, live_server, selenium):
+        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)  # noqa
+        selenium.get(live_server.url)
+        assert not find_element(selenium, "//div[contains(@class, 'sidebar')]")
+        login(selenium, user.email, USER_PASSWORD)
+        assert find_element(selenium, "//div[contains(@class, 'sidebar')]")
+
+    def test_login_failure(self, live_server, selenium):
+        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)  # noqa
+        selenium.get(live_server.url)
+        assert not find_element(selenium, "//p[@type='error']")
+        login(selenium, user.email + "Wrong Name", USER_PASSWORD)
+        assert find_element(selenium, "//p[@type='error']")

wbcore/tests/models.py

@@ -0,0 +1,6 @@
+from wbcore.contrib.guardian.models.mixins import PermissionObjectModelMixin
+
+
+class PermissionTestModel(PermissionObjectModelMixin):
+    class Meta(PermissionObjectModelMixin.Meta):
+        managed = False

wbcore/tests/test_cache/test_decorators.py

@@ -0,0 +1,28 @@
+import pytest
+
+from wbcore.cache.decorators import cache_table
+from wbcore.cache.registry import periodic_cache_registry
+
+
+@pytest.mark.parametrize(
+    "timeout, key_prefix, periodic_caching_view_kwargs, periodic_caching_get_parameters",
+    [(2, "Foo", [{"a": "a"}], [{"b": "b"}])],
+)
+def test_cache_table(timeout, key_prefix, periodic_caching_view_kwargs, periodic_caching_get_parameters):
+    @cache_table(
+        timeout=timeout,
+        key_prefix=key_prefix,
+        periodic_caching=True,
+        periodic_caching_view_kwargs=periodic_caching_view_kwargs,
+        periodic_caching_get_parameters=periodic_caching_get_parameters,
+    )
+    class CacheTable:
+        pass
+
+    assert CacheTable.CACHE_ENABLED is True
+    assert CacheTable.CACHE_TIMEOUT == timeout
+    assert CacheTable.CACHE_KEY_PREFIX == key_prefix
+    cache_entry = periodic_cache_registry.classes[0]
+    assert cache_entry.view_class == CacheTable
+    assert cache_entry.view_kwargs == periodic_caching_view_kwargs
+    assert cache_entry.get_parameters == periodic_caching_get_parameters

wbcore/tests/test_cache/test_mixins.py

@@ -0,0 +1,30 @@
+import pytest
+from faker import Faker
+
+from wbcore.cache.decorators import cache_table
+from wbcore.cache.mixins import CacheMixin
+from wbcore.utils.strings import camel_to_snake_case
+
+fake = Faker()
+
+
+class TestCacheMixin:
+    @pytest.fixture
+    def view_class(self):
+        @cache_table(
+            timeout=lambda view: view.timeout,
+            key_prefix=lambda view: view.get_parameter_value,
+        )
+        class CacheTable(CacheMixin):
+            timeout = fake.pyint()
+            get_parameter_value = fake.word()
+
+        return CacheTable
+
+    def test_get_cache_timeout(self, view_class):
+        view = view_class()
+        assert view._get_cache_timeout() == view_class.timeout
+
+    def test_get_cache_key(self, view_class):
+        view = view_class()
+        assert view._get_cache_key() == camel_to_snake_case(view_class.__name__) + "-" + view_class.get_parameter_value

wbcore/tests/test_cache/test_registry.py

@@ -0,0 +1,58 @@
+import pytest
+from django.core.cache import cache
+from dynamic_preferences.models import global_preferences_registry
+from faker import Faker
+
+from wbcore.cache.registry import CachedClass
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.viewsets import ChartViewSet
+
+fake = Faker()
+
+
+class TestClass(ChartViewSet):
+    test = fake.word()
+
+    def _get_dataframe(self):
+        return {"figure": "b"}
+
+    def _get_cache_key(self) -> str:
+        return "test-class-cache"
+
+
+@pytest.mark.django_db
+class TestCachedClass:
+    @pytest.fixture()
+    def system_user(self):
+        return UserFactory.create(
+            is_superuser=True, email=global_preferences_registry.manager()["wbcore__system_user_email"]
+        )
+
+    @pytest.fixture()
+    def cache_class(self, view_kwargs, get_parameters):
+        return CachedClass(
+            view_class=TestClass,
+            view_kwargs=view_kwargs,
+            get_parameters=get_parameters,
+        )
+
+    @pytest.mark.parametrize("get_parameters, view_kwargs", [([{"a": "b"}], [{}])])
+    def test__get_requests(self, get_parameters, view_kwargs, system_user, cache_class):
+        request = list(cache_class._get_requests())[0]
+        assert request.user == system_user
+        assert request.GET.dict() == get_parameters[0]
+
+    @pytest.mark.parametrize("get_parameters, view_kwargs", [(lambda: [{"a": TestClass.test}], [{}])])
+    def test__get_requests_callable(self, system_user, cache_class):
+        request = list(cache_class._get_requests())[0]
+        assert request.user == system_user
+        assert request.GET.dict() == {"a": cache_class.view_class.test}
+
+    @pytest.mark.parametrize("get_parameters, view_kwargs", [([{}], [{"a": "b"}])])
+    def test_fetch_cache(self, system_user, cache_class):
+        cache.set(
+            "test-class-cache", {"other_figure": "c"}
+        )  # ensure that fetch cache clear cache before refetching result
+
+        res = cache_class.fetch_cache()[0]
+        assert res == {"figure": "b"}

wbcore/tests/test_configs.py

@@ -0,0 +1,58 @@
+import pytest
+from django.conf import settings
+
+from wbcore.configs.decorators import register_config
+from wbcore.configs.registry import ConfigRegistry
+from wbcore.configs.views import ConfigAPIView
+
+
+def test_registry(config_registry: ConfigRegistry):
+    configs = config_registry.get_config_dict()
+    assert configs.keys()
+
+
+def test_release_note_config(config_registry: ConfigRegistry):
+    release_notes = config_registry.get_config_dict()["release_notes"]
+    assert release_notes["endpoint"]
+    assert release_notes["unread_release_notes"]
+
+
+def test_menu_config(config_registry: ConfigRegistry):
+    menu = config_registry.get_config_dict()["menu"]
+    assert menu
+
+
+def test_share_config(config_registry: ConfigRegistry):
+    share = config_registry.get_config_dict()["share"]
+    assert share
+
+
+def test_menu_calendar_config(config_registry: ConfigRegistry):
+    menu_calendar = config_registry.get_config_dict()["menu_calendar"]
+    assert menu_calendar
+
+
+@pytest.mark.parametrize("text, version", [("Foo bar", "Foo")])
+def test_beta_button_config(config_registry: ConfigRegistry, text, version):
+    settings.BETA_BUTTON_VERSION = version
+    settings.BETA_BUTTON_TEXT = text
+    beta_calendar = config_registry.get_config_dict()["beta_button"]
+    assert beta_calendar["url"] == f"{settings.CDN_BASE_ENDPOINT_URL}/{version}/main.js"
+    assert beta_calendar["text"] == text
+
+
+def test_config_registry_decorator():
+    def some_callable():
+        pass
+
+    assert not hasattr(some_callable, "_is_config")
+    some_callable = register_config(some_callable)
+    assert some_callable._is_config
+
+
+def test_config_view(rf):
+    request = rf.get("/")
+    view = ConfigAPIView.as_view()
+    response = view(request)
+
+    assert response.status_code == 200

wbcore/tests/test_enums.py

@@ -0,0 +1,56 @@
+import pytest
+
+from wbcore.enums import Unit
+from wbcore.metadata.configs.buttons.enums import Button
+
+
+class TestUnit:
+    @pytest.mark.parametrize("unit", [Unit.FRACTION, Unit.REM, Unit.PIXEL])
+    @pytest.mark.parametrize("value", ["1.0", 1.0, 1])
+    def test_unit(self, unit, value):
+        assert unit.unit(value) == f"{float(value)}{unit.value}"
+
+    @pytest.mark.parametrize("unit", [Unit.FRACTION, Unit.REM, Unit.PIXEL])
+    @pytest.mark.parametrize("value, exception", [("a", ValueError), (None, AssertionError)])
+    def test_unit_fail(self, unit, value, exception):
+        with pytest.raises(exception):
+            unit.unit(value)
+
+
+class TestButton:
+    @pytest.mark.parametrize(
+        "method, buttons",
+        [
+            (
+                "buttons",
+                [
+                    Button.REFRESH.value,
+                    Button.NEW.value,
+                    Button.DELETE.value,
+                    Button.SAVE.value,
+                    Button.SAVE_AND_CLOSE.value,
+                    Button.SAVE_AND_NEW.value,
+                ],
+            ),
+            (
+                "create_buttons",
+                [
+                    Button.SAVE.value,
+                    Button.SAVE_AND_CLOSE.value,
+                    Button.SAVE_AND_NEW.value,
+                    Button.RESET.value,
+                ],
+            ),
+            (
+                "custom_buttons",
+                [
+                    Button.DROPDOWN.value,
+                    Button.HYPERLINK.value,
+                    Button.WIDGET.value,
+                    Button.ACTION.value,
+                ],
+            ),
+        ],
+    )
+    def test_methods(self, method, buttons):
+        assert getattr(Button, method)() == buttons