wbcore 2.2.1__py2.py3-none-any.whl

wbcore/tests/test_filters/test_pandas.py

@@ -0,0 +1,114 @@
+from collections import namedtuple
+
+import pandas as pd
+import pytest
+from rest_framework.test import APIRequestFactory
+from wbcore.pandas.filters import PandasOrderingFilter
+from wbcore.viewsets import ViewSet
+
+
+class TestPandasOrderingFilter:
+    @pytest.fixture
+    def ordering_filter(self):
+        return PandasOrderingFilter()
+
+    @pytest.fixture
+    def view(self, base_ordering_fields, ordering_fields):
+        class BaseView(ViewSet):
+            def get_ordering_fields(self):
+                return base_ordering_fields
+
+            ordering = ordering_fields
+
+        return BaseView()
+
+    @pytest.fixture
+    def df(self, ordering_fields):
+        return pd.DataFrame(
+            [[1] * len(ordering_fields), [2] * len(ordering_fields)],
+            columns=map(lambda x: x.replace("-", ""), ordering_fields),
+        )
+
+    @pytest.fixture
+    def queryset(self):
+        # dummy iterable to assert that the filter queryset method doesn't touch the queryset
+        return [namedtuple("Point", "x y")]
+
+    @pytest.fixture
+    def filter_request(self, ordering_fields):
+        factory = APIRequestFactory()
+        request = factory.get(f'/?ordering={",".join(ordering_fields)}')
+        request.query_params = request.GET
+        return request
+
+    @pytest.mark.parametrize(
+        "base_ordering_fields, ordering_fields, expected_ordering_fields, expected_ascending",
+        [
+            (["a", "b"], ["a"], ["a"], [True]),
+            (["a", "b"], ["c"], [], []),
+            (["a", "b"], ["-a"], ["a"], [False]),
+            (["a", "b"], ["-a", "b"], ["a", "b"], [False, True]),
+        ],
+    )
+    def test_get_ordering(
+        self,
+        base_ordering_fields,
+        ordering_fields,
+        expected_ordering_fields,
+        expected_ascending,
+        ordering_filter,
+        filter_request,
+        df,
+        view,
+    ):
+        res_ordering_fields, res_ascending = ordering_filter.get_ordering(filter_request, df, view)
+        assert list(res_ordering_fields) == expected_ordering_fields
+        assert list(res_ascending) == expected_ascending
+
+    @pytest.mark.parametrize(
+        "base_ordering_fields, ordering_fields, expected_ordering_fields, expected_ascending",
+        [
+            (["a", "b"], ["a"], ["a"], [True]),
+            (["a", "b"], ["c"], [], []),
+            (["a", "b"], ["-a"], ["a"], [False]),
+            (["a", "b"], ["-a", "b"], ["a", "b"], [False, True]),
+        ],
+    )
+    def test_get_ordering_without_query_params(
+        self,
+        base_ordering_fields,
+        ordering_fields,
+        expected_ordering_fields,
+        ordering_filter,
+        expected_ascending,
+        df,
+        rf,
+        view,
+    ):
+        rf.query_params = {}
+        res_ordering_fields, res_ascending = ordering_filter.get_ordering(rf, df, view)
+        assert list(res_ordering_fields) == expected_ordering_fields
+        assert list(res_ascending) == expected_ascending
+
+    @pytest.mark.parametrize(
+        "base_ordering_fields, ordering_fields",
+        [
+            (["a", "b"], ["a"]),
+        ],
+    )
+    def test_filter_queryset(
+        self, base_ordering_fields, ordering_fields, ordering_filter, filter_request, queryset, view
+    ):
+        assert ordering_filter.filter_queryset(filter_request, queryset, view) == queryset
+
+    @pytest.mark.parametrize(
+        "base_ordering_fields, ordering_fields",
+        [
+            (["a", "b"], ["-a"]),
+        ],
+    )
+    def test_filter_dataframe(self, base_ordering_fields, ordering_fields, ordering_filter, filter_request, df, view):
+        assert list(ordering_filter.filter_dataframe(filter_request, df, view)["a"].values) == [
+            2,
+            1,
+        ]  # we just check that ordering is applied

wbcore/tests/test_list_display.py

@@ -0,0 +1,31 @@
+from wbcore.metadata.configs.display.list_display import (
+    ListDisplay,
+    TreeGroupLevelOption,
+)
+
+
+def test_tree_group_open_level_list_display():
+    ld = dict(
+        ListDisplay(
+            fields=[],
+            tree=True,
+            tree_group_field="field",
+            tree_group_label="label",
+            tree_group_open_level=3,
+            tree_group_level_options=[TreeGroupLevelOption(list_endpoint="endpoint")],
+        )
+    )
+    assert ld["tree_group"]["open_level"] == 3
+
+
+def test_not_tree_group_open_level_list_display():
+    ld = dict(
+        ListDisplay(
+            fields=[],
+            tree=False,
+            tree_group_field="field",
+            tree_group_label="label",
+            tree_group_open_level=3,
+        )
+    )
+    assert "tree_group" not in ld

wbcore/tests/test_models/test_fields.py

@@ -0,0 +1,25 @@
+import pytest
+from django.core.exceptions import ValidationError
+from wbcore.models.fields import validate_year
+
+
+class TestYearField:
+    @pytest.mark.parametrize(
+        ("input", "valid"),
+        [
+            (3, False),
+            (24, False),
+            (165, False),
+            (41877, False),
+            (2065, True),
+            (1969, True),
+            (1283, True),
+            (None, True),
+        ],
+    )
+    def test_year_validator(self, input, valid):
+        if valid:
+            validate_year(input)
+        else:
+            with pytest.raises(ValidationError):
+                validate_year(input)

wbcore/tests/test_models/test_mixins.py

@@ -0,0 +1,31 @@
+from django.db import models
+from wbcore.models.orderable import OrderableModel
+
+
+class ForeignKeyClass(models.Model):
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbcore:foreignkeyclass"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+
+class OrderableChild(OrderableModel):
+    PARTITION_BY = "partition_fk"
+
+    partition_fk = models.ForeignKey(
+        to=ForeignKeyClass,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+    )
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbcore:orderablechild"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"

wbcore/tests/test_new_display/test_inlines.py

@@ -0,0 +1,13 @@
+from wbcore.metadata.configs.display.instance_display.layouts.inlines import Inline
+
+
+class TestInline:
+    def test_init(self):
+        inline = Inline(key="key", endpoint="endpoint")
+        assert inline is not None
+
+    def test_serialize(self):
+        inline = Inline(key="key", endpoint="endpoint")
+        assert inline.serialize() == {"key": "key", "endpoint": "endpoint", "hide_controls": False}
+
+    # TODO: Test with display

wbcore/tests/test_new_display/test_layouts.py

@@ -0,0 +1,15 @@
+from wbcore.metadata.configs.display.instance_display.layouts.layouts import Layout
+
+
+class TestLayout:
+    def test_minimal_init(self):
+        assert Layout([[]]) is not None
+
+    def test_minimal_serialize(self):
+        assert Layout([[]]).serialize() == {
+            "gridTemplateAreas": "''",
+            "sections": [],
+            "inlines": [],
+            "gap": "10px",
+            "gridAutoRows": "min-content",
+        }

wbcore/tests/test_new_display/test_operators.py

@@ -0,0 +1,15 @@
+import pytest
+from wbcore.metadata.configs.display.instance_display import operators
+
+
+@pytest.mark.parametrize(
+    "method, value, result",
+    [
+        (operators.lt, 20, "<20"),
+        (operators.lte, 20, "<=20"),
+        (operators.gt, 20, ">20"),
+        (operators.gte, 20, ">=20"),
+    ],
+)
+def test_operator(method, value, result):
+    assert method(value) == result

wbcore/tests/test_new_display/test_pages.py

@@ -0,0 +1,8 @@
+from wbcore.metadata.configs.display.instance_display import operators as op
+from wbcore.metadata.configs.display.instance_display.layouts.layouts import Layout
+from wbcore.metadata.configs.display.instance_display.pages import Page
+
+
+class TestPage:
+    def test_init(self):
+        assert Page(layouts={op.default(): Layout([[]])}) is not None

wbcore/tests/test_new_display/test_shortcuts.py

@@ -0,0 +1,38 @@
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+    create_simple_section,
+)
+
+
+def test_create_simple_display():
+    assert create_simple_display([["field1", "field2"], ["field3", "field4"]]).serialize() == {
+        "navigationType": "tab",
+        "pages": [
+            {
+                "layouts": {
+                    "default": {
+                        "gridTemplateAreas": "'field1 field2' 'field3 field4'",
+                        "inlines": [],
+                        "sections": [],
+                        "gap": "10px",
+                        "gridAutoColumns": "1fr",
+                        "gridAutoRows": "min-content",
+                    }
+                },
+                "title": None,
+            }
+        ],
+    }
+
+
+def test_create_simple_section():
+    section = create_simple_section(
+        key="key", title="title", grid_template_areas=[["field1", "field2"]], inline_key="field1", collapsible=False
+    ).serialize()
+    assert section["key"] == "key"
+    assert section["title"] == "title"
+    assert section["display"]["pages"][0]["layouts"]["default"]["gridTemplateAreas"] == "'field1 field2'"  # type: ignore
+    assert section["display"]["pages"][0]["layouts"]["default"]["inlines"] == (  # type: ignore
+        [{"key": "field1", "endpoint": "field1", "hide_controls": False}]
+    )
+    assert not section["collapsible"]

wbcore/tests/test_new_display/test_utils.py

@@ -0,0 +1,48 @@
+from random import randint
+
+import pytest
+from wbcore.metadata.configs.display.instance_display.styles import Style
+from wbcore.metadata.configs.display.instance_display.utils import (
+    grid_definition,
+    repeat,
+    repeat_field,
+    split_list_into_grid_template_area_sublists,
+)
+
+
+def test_repeat():
+    assert repeat(2, Style.px(20)) == "repeat(2, 20px)"
+
+
+def test_repeat_field():
+    assert repeat_field(2, Style.px(20)) == "20px 20px"
+
+
+def test_grid_definition():
+    assert grid_definition(Style.px(20), Style.px(10), Style.px(20)) == "20px 10px 20px"
+
+
+@pytest.mark.parametrize(
+    ("input", "output"),
+    [
+        ([], [[".", ".", "."]]),
+        (["abc", "d"], [["abc", "d", "."]]),
+        (["abc", "d", "ef"], [["abc", "d", "ef"]]),
+        (["dh", "faf", "fsefs", "ss"], [["dh", "faf", "fsefs"], ["ss", ".", "."]]),
+        (["dh", "faf", "fsefs", "ss", "rty", "dthf"], [["dh", "faf", "fsefs"], ["ss", "rty", "dthf"]]),
+    ],
+)
+def test_split_list_into_grid_template_area_sublists(input, output):
+    assert split_list_into_grid_template_area_sublists(input, 3) == output
+
+
+def test_split_list_into_grid_template_area_sublists_error():
+    with pytest.raises(ValueError):
+        split_list_into_grid_template_area_sublists(["abc"], -3)
+
+
+def test_split_list_into_grid_template_area_sublists_random():
+    column_number = randint(1, 5)
+    field_list = ["Test" for _ in range(0, 15)]
+    for sublist in split_list_into_grid_template_area_sublists(field_list, column_number):
+        assert len(sublist) == column_number

wbcore/tests/test_pagination.py

@@ -0,0 +1,31 @@
+from rest_framework import serializers
+from rest_framework.generics import ListAPIView
+from rest_framework.test import APIRequestFactory
+from wbcore.pagination import LimitOffsetPagination
+
+factory = APIRequestFactory()
+
+
+class TestEndlessPaginationMixin:
+    def setup_method(self):
+        class PassThroughSerializer(serializers.Serializer):
+            def to_representation(self, instance):
+                return instance
+
+        self.view = ListAPIView.as_view(
+            serializer_class=PassThroughSerializer,
+            queryset=range(1, 101),
+            pagination_class=LimitOffsetPagination,
+            authentication_classes=[],
+            permission_classes=[],
+        )
+
+    def test_paginate_queryset_with_pagination(self):
+        request = factory.get("/")
+        response = self.view(request)
+        assert len(response.data["results"]) == 25
+
+    def test_paginate_queryset_without_pagination(self):
+        request = factory.get("/", {"disable_pagination": "true"})
+        response = self.view(request)
+        assert len(response.data) == 100

wbcore/tests/test_serializers/test_fields.py

@@ -0,0 +1,140 @@
+import pytest
+from rest_framework import serializers
+from rest_framework.test import APIRequestFactory
+from wbcore.serializers.fields import CharField
+
+
+@pytest.fixture
+def char_field_base():
+    field_name = "test_field"
+    request = APIRequestFactory().get("")
+    default_placeholder = "Enter text here"
+    secure_flag = True
+    return {
+        "field_name": field_name,
+        "request": request,
+        "default_placeholder": default_placeholder,
+        "secure_flag": secure_flag,
+    }
+
+
+class TestCharFieldInitialization:
+    """Tests for the initialization of the CharField class."""
+
+    def test_default_initialization(self):
+        """Test CharField default initialization with no custom parameters."""
+        field = CharField()
+        assert field.allow_null is True
+        assert field.allow_blank is False
+        assert field.placeholder is None
+        assert field.secure is False
+
+    def test_custom_initialization(self, char_field_base):
+        """Test CharField initialization with custom placeholder and secure parameters."""
+        field = CharField(placeholder=char_field_base["default_placeholder"], secure=char_field_base["secure_flag"])
+        assert field.placeholder == char_field_base["default_placeholder"]
+        assert field.secure is True
+
+    def test_empty_string_placeholder(self, char_field_base):
+        """Test that an empty string as a placeholder does not appear in the representation."""
+        field = CharField(placeholder="")
+        assert field.placeholder == ""
+        _, representation = field.get_representation(char_field_base["request"], char_field_base["field_name"])
+        assert "placeholder" not in representation
+
+    def test_non_boolean_secure(self, char_field_base):
+        """
+        Test non-boolean values for the 'secure' attribute.
+
+        Non-boolean values are expected to be treated as truthy (e.g., "no" should behave like True).
+        """
+        field = CharField(secure="no")
+        _, representation = field.get_representation(char_field_base["request"], char_field_base["field_name"])
+        assert "secure" in representation
+        assert representation["secure"] is True
+
+
+class TestCharFieldRepresentation:
+    """Tests for the representation of the CharField class."""
+
+    def test_representation_without_placeholder_and_secure(self, char_field_base):
+        """Test CharField representation without custom placeholder or secure attributes."""
+        field = CharField()
+        _, representation = field.get_representation(char_field_base["request"], char_field_base["field_name"])
+        assert "placeholder" not in representation
+        assert "secure" not in representation
+
+    def test_representation_with_placeholder(self, char_field_base):
+        """Test CharField representation with a custom placeholder."""
+        field = CharField(placeholder="Enter text here")
+        _, representation = field.get_representation(char_field_base["request"], char_field_base["field_name"])
+        assert "placeholder" in representation
+        assert representation["placeholder"] == "Enter text here"
+
+    def test_representation_with_secure(self, char_field_base):
+        """Test CharField representation with the secure attribute enabled."""
+        field = CharField(secure=True)
+        _, representation = field.get_representation(char_field_base["request"], char_field_base["field_name"])
+        assert "secure" in representation
+        assert representation["secure"] is True
+
+    def test_representation_with_placeholder_and_secure(self, char_field_base):
+        """Test CharField representation with both placeholder and secure attributes."""
+        field = CharField(placeholder="Enter text here", secure=True)
+        _, representation = field.get_representation(char_field_base["request"], char_field_base["field_name"])
+        assert "placeholder" in representation
+        assert representation["placeholder"] == "Enter text here"
+        assert "secure" in representation
+        assert representation["secure"] is True
+
+
+class TestCharFieldValidation:
+    """Tests for the validation of empty values in the CharField class."""
+
+    def test_validate_empty_with_allow_null_true(self):
+        """Test validation when allow_null is True and data is None."""
+        field = CharField(allow_null=True, allow_blank=False)
+        should_validate, data = field.validate_empty_values(None)
+        assert data == ""
+        assert should_validate is False
+
+    def test_validate_empty_with_allow_blank_true(self):
+        """Test validation when allow_blank is True and data is None."""
+        field = CharField(allow_blank=True, allow_null=False)
+        should_validate, data = field.validate_empty_values(None)
+        assert data == ""
+        assert should_validate is False
+
+    def test_validate_empty_with_allow_null_and_allow_blank_false(self):
+        """Test validation when both allow_null and allow_blank are False and data is None."""
+        field = CharField(allow_null=False, allow_blank=False)
+        with pytest.raises(serializers.ValidationError):
+            field.validate_empty_values(None)
+
+    def test_validate_empty_with_allow_null_and_allow_blank_true(self):
+        """Test validation when both allow_null and allow_blank are True and data is None."""
+        field = CharField(allow_null=True, allow_blank=True)
+        should_validate, data = field.validate_empty_values(None)
+        assert data == ""
+        assert should_validate is False
+
+    def test_validate_empty_with_non_none_data(self):
+        """Test validation when data is a non-empty string."""
+        field = CharField()
+        should_validate, data = field.validate_empty_values("Test")
+        assert data == "Test"
+        assert should_validate is False
+
+    def test_validate_empty_with_empty_string_data(self):
+        """Test validation when data is an empty string."""
+        field = CharField(allow_blank=True, allow_null=False)
+        should_validate, data = field.validate_empty_values("")
+        assert data == ""
+        assert should_validate is False
+
+    def test_validate_empty_with_whitespace_string_data(self):
+        """Test validation when data is a whitespace string."""
+        field = CharField(allow_blank=True, allow_null=False)
+        should_validate, data = field.validate_empty_values("   ")
+        assert data == "   "
+        assert should_validate is False

wbcore/tests/test_serializers/test_mixins.py

@@ -0,0 +1,53 @@
+from collections import namedtuple
+
+import pytest
+from wbcore.serializers import Serializer
+from wbcore.serializers.fields.number import IntegerField
+
+
+class TestWBCoreSerializerFieldMixin:
+    @pytest.fixture()
+    def parent(self, context=None):
+        if not context:
+            context = {"view": object()}
+        return Serializer(context=context)
+
+    def test_read_only_callable(self):
+        # check default readonly handling
+        field = IntegerField(read_only=True)
+        assert field.read_only is True
+
+        field = IntegerField(read_only=False)
+        assert field.read_only is False
+
+        field = IntegerField(read_only=lambda x: True)
+        assert field.read_only is True
+        assert hasattr(field, "_callable_read_only")
+
+    def test_bind_read_only_callable(self, parent):
+        field = IntegerField(read_only=lambda view: False)
+        field.bind("field", parent)
+        assert field.read_only is False
+
+    def test_view(self):
+        view = object()
+        Request = namedtuple("Request", ["parser_context"])
+        request = Request({"view": view})
+
+        c1 = {"view": view}
+        c2 = {"request": request}
+
+        field = IntegerField()
+        p1 = Serializer(context=c1)
+        field.bind("field", p1)
+        assert field.view == view
+
+        field = IntegerField()
+        p1 = Serializer(context=c2)
+        field.bind("field", p1)
+        assert field.view == view
+
+        field = IntegerField()
+        p1 = Serializer()
+        field.bind("field", p1)
+        assert field.view is None

wbcore/tests/test_serializers/test_related.py

@@ -0,0 +1,77 @@
+import pytest
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.authentication.models import User
+from wbcore.serializers import PrimaryKeyRelatedField, RepresentationSerializer
+
+
+class TestRepresentationSerializer:
+    @pytest.fixture()
+    def test_representation_serializer(self):
+        class TestFixtureRepresentationSerializer(RepresentationSerializer):
+            filter_params = {"a": "a"}
+
+            class Meta:
+                model = User
+                fields = ("id",)
+
+        return TestFixtureRepresentationSerializer
+
+    @pytest.fixture()
+    def option_request(self):
+        factory = APIRequestFactory()
+        return factory.get("/")
+
+    def test_filter_params(self, test_representation_serializer, option_request):
+        serializer = test_representation_serializer(source="source")
+        assert serializer._get_filter_params(option_request) == {"a": "a"}
+
+        assert serializer.get_representation(option_request, "id")[1]["endpoint"]["url"].endswith("?a=a")
+        # assert kwargs override class attribute
+        serializer = test_representation_serializer(source="source", filter_params={"b": "b"})
+        assert serializer._get_filter_params(option_request) == {"b": "b"}
+
+        serializer = test_representation_serializer(source="source", ignore_filter=True)
+        assert serializer._get_filter_params(option_request) == dict()
+
+    def test_filter_params_with_method(self, option_request):
+        class TestFixtureRepresentationSerializer(RepresentationSerializer):
+            def get_filter_params(self, *args):
+                return {"c": "c"}
+
+            class Meta:
+                model = User
+                fields = ("id",)
+
+        serializer = TestFixtureRepresentationSerializer(source="source", filter_params={"b": "b"})
+        assert serializer._get_filter_params(option_request) == {
+            "b": "b"
+        }  # kwargs or class attributes take precedance
+
+        serializer = TestFixtureRepresentationSerializer(source="source")
+        assert serializer._get_filter_params(option_request) == {
+            "c": "c"
+        }  # kwargs or class attributes take precedance
+
+    def test_queryset_unset_if_read_only_callable(self):
+        u1 = UserFactory.build()
+        UserFactory.build()  # noisy user
+        queryset = [u1]
+        # test that the queryset is properly unset if the readonly attribute is a callable and behave normally otherwise
+        related_field = PrimaryKeyRelatedField(read_only=False, queryset=queryset)
+        assert related_field.queryset == queryset
+        with pytest.raises(AssertionError):
+            PrimaryKeyRelatedField(read_only=True, queryset=queryset)
+
+        related_field = PrimaryKeyRelatedField(read_only=lambda: True, queryset=queryset)
+        assert related_field.queryset is None
+
+    def test_related_field_binding_reinstate_queryset_on_readonly_callable(self, test_representation_serializer):
+        u1 = UserFactory.build()
+        UserFactory.build()  # noisy user
+        queryset = [u1]
+        parent = test_representation_serializer(context={"view": object()})
+        related_field = PrimaryKeyRelatedField(read_only=lambda view: False, queryset=queryset)
+        assert related_field.queryset is None
+        related_field.bind("related_field", parent)
+        assert related_field.queryset == queryset