wbcore 1.46.0__py2.py3-none-any.whl → 1.58.2__py2.py3-none-any.whl

wbcore/serializers/fields/mixins.py

@@ -10,8 +10,10 @@ logger = logging.getLogger(__name__)
 
 
 def decorator(position: str, value: str, decorator_type: str = "icon") -> dict:
-    assert position in ("left", "right"), "Decorator Position can only be right or left"
-    assert decorator_type in ("icon", "text"), "Decorator Type can only be icon or text"
+    if position not in ("left", "right"):
+        raise ValueError("Decorator Position can only be right or left")
+    if decorator_type not in ("icon", "text"):
+        raise ValueError("Decorator Type can only be icon or text")
     return {"position": position, "value": value, "type": decorator_type}
 
 
@@ -31,6 +33,8 @@ class WBCoreSerializerFieldMixin:
         read_only=False,
         copyable=None,
         related_key=None,
+        on_unsatisfied_deps="read_only",
+        clear_dependent_fields=True,
         **kwargs,
     ):
         if not decorators:
@@ -48,6 +52,8 @@ class WBCoreSerializerFieldMixin:
             self._callable_read_only = read_only
             read_only = True
         self.related_key = related_key
+        self.on_unsatisfied_deps = on_unsatisfied_deps
+        self.clear_dependent_fields = clear_dependent_fields
         super().__init__(*args, read_only=read_only, **kwargs)
 
     def _evaluate_read_only(self, field_name, parent):
@@ -105,12 +111,8 @@ class WBCoreSerializerFieldMixin:
 
         default = getattr(self, "default", None)
         if default is None or default == empty or default == NOT_PROVIDED:
-            try:
-                default = self.parent.Meta.model._meta._forward_fields_map[
-                    field_name
-                ].default
-            except Exception:  # TODO Add some explicit exception handling
-                pass
+            with suppress(Exception):  # TODO Add some explicit exception handling
+                default = self.parent.Meta.model._meta._forward_fields_map[field_name].default
 
         if default is not None and default != empty and default != NOT_PROVIDED:
             if callable(default):
@@ -133,6 +135,10 @@ class WBCoreSerializerFieldMixin:
             representation["math"] = self.math
         if self.copyable:
             representation["copyable"] = self.copyable
+        if self.on_unsatisfied_deps != "read_only":
+            representation["on_unsatisfied_deps"] = self.on_unsatisfied_deps
+        if self.clear_dependent_fields is not True:
+            representation["clear_dependent_fields"] = self.clear_dependent_fields
         return field_name, representation
 
     def validate_empty_values(self, data):
@@ -173,9 +179,16 @@ class RangeMixin(WBCoreSerializerFieldMixin, Field):
         return self.internal_field(lower, upper)
 
     def to_representation(self, instance):
-        lower, upper = self._transform_range(
-            instance.lower, instance.upper, inward=False
-        )
+        if hasattr(instance, "lower"):
+            lower = instance.lower
+        else:
+            lower = instance[0]
+
+        if hasattr(instance, "upper"):
+            upper = instance.upper
+        else:
+            upper = instance[1]
+        lower, upper = self._transform_range(lower, upper, inward=False)
         with suppress(Exception):
             lower = super().to_representation(lower)
         with suppress(Exception):

wbcore/serializers/fields/number.py

@@ -14,19 +14,12 @@ class NumberFieldMixin:
         percent=False,
         display_mode=DisplayMode.DECIMAL,
         precision=2,
-        delimiter=",",
-        decimal_mark=".",
         signed: bool = True,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
         self.percent = percent
-        self.delimiter = delimiter
-        self.decimal_mark = decimal_mark
-        if self.delimiter == self.decimal_mark:
-            raise ValueError(
-                "Decimal mark and delimiter need to be different character"
-            )
+        self.disable_formatting = getattr(self, "disable_formatting", kwargs.pop("disable_formatting", False))
         self.display_mode = display_mode
         self.precision = kwargs.get("decimal_places", precision)
         self.max_digits = kwargs.get("max_digits", 34)
@@ -45,8 +38,7 @@ class NumberFieldMixin:
         representation["display_mode"] = self.display_mode.value
         representation["precision"] = self.precision
         representation["max_digits"] = self.max_digits
-        representation["delimiter"] = self.delimiter
-        representation["decimal_mark"] = self.decimal_mark
+        representation["disable_formatting"] = self.disable_formatting
         representation["signed"] = self.signed
 
         if self.percent:  # TODO: Discuss with Christoph if this is necessary like this
@@ -55,9 +47,7 @@ class NumberFieldMixin:
         return key, representation
 
 
-class IntegerField(
-    NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.IntegerField
-):
+class IntegerField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.IntegerField):
     field_type = WBCoreType.NUMBER.value
 
     def __init__(self, *args, **kwargs):
@@ -66,15 +56,10 @@ class IntegerField(
 
 
 class YearField(IntegerField):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.delimiter = ""
-        self.decimal_mark = "."
+    disable_formatting = True
 
 
-class DecimalField(
-    NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.DecimalField
-):
+class DecimalField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.DecimalField):
     field_type = WBCoreType.NUMBER.value
 
     # TODO: If this is used, then the validation for max_digits and decimal_fields is not done
@@ -97,9 +82,7 @@ class FloatField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.Float
     field_type = WBCoreType.NUMBER.value
 
 
-class DecimalRangeField(
-    RangeMixin, WBCoreSerializerFieldMixin, serializers.DecimalField
-):
+class DecimalRangeField(RangeMixin, WBCoreSerializerFieldMixin, serializers.DecimalField):
     field_type = WBCoreType.NUMBERRANGE.value
     internal_field = NumericRange
 

wbcore/serializers/fields/other.py

@@ -7,20 +7,12 @@ from .number import IntegerField
 
 class StarRatingField(IntegerField):
     field_type = "starrating"
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.delimiter = ""
-        self.decimal_mark = ""
+    disable_formatting = True
 
 
 class EmojiRatingField(IntegerField):
     field_type = "emojirating"
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.delimiter = ""
-        self.decimal_mark = ""
+    disable_formatting = True
 
 
 class RangeSelectField(WBCoreSerializerFieldMixin, serializers.FloatField):

wbcore/serializers/fields/related.py

@@ -29,7 +29,7 @@ class WBCoreManyRelatedField(ListFieldMixin, WBCoreSerializerFieldMixin, ManyRel
         self.child_relation.context["view"] = self.view
         self.child_relation._evaluate_read_only(field_name, parent)
         if not self.child_relation.read_only and hasattr(self.child_relation, "_queryset"):
-            setattr(self.child_relation, "queryset", self.child_relation._queryset)
+            self.child_relation.queryset = self.child_relation._queryset
 
     def get_representation(self, request: Request, field_name: str) -> tuple[str, dict]:
         key, representation = self.child_relation.get_representation(request, field_name)
@@ -58,7 +58,7 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
     )
 
     def __init__(self, *args, queryset=None, read_only=False, **kwargs):
-        self.field_type = kwargs.pop("field_type", WBCoreType.SELECT.value)
+        self.field_type = kwargs.pop("field_type", WBCoreType.PRIMARY_KEY.value)
         if callable(read_only) and queryset is not None:
             self._queryset = queryset  # we unset any given queryset to be compliant with the RelatedField assertion
             queryset = None
@@ -72,7 +72,7 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
         super().bind(field_name, parent)
         # In case we had to unset the queryset attribute because read_only was a callable, we reinstate it here.
         if not self.read_only and hasattr(self, "_queryset"):
-            setattr(self, "queryset", self._queryset)
+            self.queryset = self._queryset
 
     @classmethod
     def many_init(cls, *args, **kwargs):
@@ -103,7 +103,7 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
         # In case we annotate the representation, we need to ensure that the value is an object
         if isinstance(value, (list, tuple, set)):
             return [self.to_representation(d) for d in value]
-        try:
+        with suppress(Exception):  # TODO: investigate what exception are we expecting here
             if isinstance(value, str):
                 try:
                     value = int(value)
@@ -112,8 +112,6 @@ class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyR
             if isinstance(value, int):
                 value = PKOnlyObject(value)
             return super().to_representation(value)
-        except Exception:
-            pass
         return None
 
     def get_queryset(self):

wbcore/serializers/fields/text.py

@@ -54,7 +54,7 @@ class CodeField(CharField):
         try:
             compile(data, "", "exec")
         except Exception as e:
-            raise ValidationError(_("Compiling script failed with the exception: {}".format(e)))
+            raise ValidationError(_("Compiling script failed with the exception: {}".format(e))) from e
         return super().to_internal_value(data)
 
 

wbcore/serializers/fields/types.py

@@ -14,6 +14,7 @@ class WBCoreType(Enum):
     DATETIMERANGE = "datetimerange"
     DATE = "date"
     DATERANGE = "daterange"
+    TIMERANGE = "timerange"
     DURATION = "duration"
     TIME = "time"
     PRIMARY_KEY = "primary_key"
@@ -29,6 +30,7 @@ class WBCoreType(Enum):
     COLOR = "color"
     URL = "url"
     SPARKLINE = "sparkline"
+    LANGUAGE = "language"
 
 
 class ReturnContentType(Enum):

wbcore/serializers/serializers.py

@@ -23,6 +23,7 @@ from timezone_field import TimeZoneField
 from wbcore.contrib.color.fields import ColorField
 from wbcore.contrib.icons.models import IconField
 from wbcore.contrib.icons.serializers import IconSelectField
+from wbcore.metadata.configs.display.list_display import BaseTreeGroupLevelOption
 from wbcore.models.fields import YearField
 from wbcore.serializers import (
     fields,
@@ -48,8 +49,8 @@ def validate_nested_representation(instance, value):
 
 
 class WBCoreSerializerMetaClass(SerializerMetaclass):
-    def __new__(cls, name, bases, dct):
-        _class = super().__new__(cls, name, bases, dct)
+    def __new__(cls, *args, **kwargs):  # noqa: C901
+        _class = super().__new__(cls, *args, **kwargs)
 
         if _meta := getattr(_class, "Meta", None):
             model = _meta.model
@@ -306,7 +307,7 @@ class ModelSerializer(
 class RepresentationSerializer(WBCoreSerializerFieldMixin, ModelSerializer):
     field_type = WBCoreType.SELECT.value
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, tree_config: BaseTreeGroupLevelOption | None = None, **kwargs):
         self.ignore_filter = kwargs.pop("ignore_filter", getattr(self, "ignore_filter", None))
         self.filter_params = kwargs.pop("filter_params", getattr(self, "filter_params", None))
         self.endpoint = kwargs.pop(
@@ -332,6 +333,8 @@ class RepresentationSerializer(WBCoreSerializerFieldMixin, ModelSerializer):
             "optional_get_parameters",
             getattr(self, "optional_get_parameters", None),
         )
+        self.tree_config = tree_config
+        self.select_first_choice = kwargs.pop("select_first_choice", getattr(self, "select_first_choice", None))
         super().__init__(*args, **kwargs)
 
     def to_representation(self, value):
@@ -408,9 +411,15 @@ class RepresentationSerializer(WBCoreSerializerFieldMixin, ModelSerializer):
             },
         }
 
+        if self.select_first_choice:
+            representation["select_first_choice"] = True
+
         if self.help_text:
             representation["help_text"] = self.help_text
 
         if self.optional_get_parameters:
             representation["endpoint"]["optional_get_parameters"] = self.optional_get_parameters
+
+        if self.tree_config:
+            representation["tree_config"] = dict(self.tree_config)
         return self.get_related_key(), representation

wbcore/signals/__init__.py

@@ -4,3 +4,4 @@ from .models import get_dependant_dynamic_fields_instances, pre_collection
 from .permissions import load_permission_objects
 from .serializers import add_additional_resource, add_instance_additional_resource, add_dynamic_button
 from .merge import pre_merge
+from .clone import post_clone

wbcore/signals/clone.py

@@ -0,0 +1,4 @@
+from django.db.models.signals import ModelSignal
+
+# Signal fired before merged/obsolete object are deleted during a merge phase
+post_clone = ModelSignal(use_caching=False)

wbcore/signals/models.py

@@ -1,8 +1,4 @@
 from django.db.models.signals import ModelSignal
 
-get_dependant_dynamic_fields_instances = (
-    ModelSignal()
-)  # Signal use to gather the dependant fields to be computed before the sender (use for the dynamic field framework). Experimental state
-pre_collection = (
-    ModelSignal()
-)  # pre_delete signal is sent after collection. Therefore, protect field will trigger an IntergrityError. This signal can be used to circuvent that.
+get_dependant_dynamic_fields_instances = ModelSignal()  # Signal use to gather the dependant fields to be computed before the sender (use for the dynamic field framework). Experimental state
+pre_collection = ModelSignal()  # pre_delete signal is sent after collection. Therefore, protect field will trigger an IntergrityError. This signal can be used to circuvent that.

wbcore/tasks.py

@@ -45,7 +45,7 @@ def recompute_computed_str(debug: bool = False):
     When this task is executed, it will loop over all objects that inherit from ComplexToStringMixin and compare their current computed_str value with the expected one.
     If different, the expected one is saved in place.
     """
-    BULK_SIZE = 1000
+    bulk_size = 1000
     for subclass in get_inheriting_subclasses(ComplexToStringMixin):
         if getattr(subclass, "COMPUTED_STR_RECOMPUTE_PERIODICALLY", True):
             objs = []
@@ -59,7 +59,7 @@ def recompute_computed_str(debug: bool = False):
                     if new_computed_str != instance.computed_str:
                         instance.computed_str = new_computed_str
                         objs.append(instance)
-                    if len(objs) % BULK_SIZE == 0:
+                    if len(objs) % bulk_size == 0:
                         subclass.objects.bulk_update(objs, ["computed_str"])
                         objs = []
             if objs:

wbcore/templates/wbcore/email_base_template.html

@@ -208,7 +208,7 @@
             width: 100%;
         }
         .fixed {
-            width: 500px;
+            width: 750px;
         }
         #body-table {
             width: 100%;
@@ -248,8 +248,8 @@
         }
         #body-table .content-row > .body-content {
             background-color: #fff;
-            padding-right: 30px;
-            padding-left: 30px;
+            padding-right: 15px;
+            padding-left: 15px;
         }
         #body-table #spacer-row > .spacer-left,
         #body-table #spacer-row > .spacer-middle,

wbcore/test/e2e_helpers_methods/e2e_checks.py

@@ -2,7 +2,7 @@ from selenium.common.exceptions import TimeoutException
 from selenium.webdriver.common.by import By
 from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.remote.webelement import WebElement
-from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support import expected_conditions
 from selenium.webdriver.support.color import Color
 from selenium.webdriver.support.wait import WebDriverWait
 
@@ -49,7 +49,9 @@ def is_string_not_visible(driver: WebDriver, string: str) -> bool:
         bool: True if the text is not visible
     """
     try:
-        WebDriverWait(driver, 5).until(EC.invisibility_of_element_located((By.XPATH, f"//*[text()='{string}']")))
+        WebDriverWait(driver, 5).until(
+            expected_conditions.invisibility_of_element_located((By.XPATH, f"//*[text()='{string}']"))
+        )
         return True
     except TimeoutException:
         return False
@@ -82,7 +84,9 @@ def is_tag_not_visible(driver: WebDriver, tag_label: str) -> bool:
     """
     try:
         WebDriverWait(driver, 2.5).until(
-            EC.invisibility_of_element_located((By.XPATH, f"//*[@class='tag-label' and text()='{tag_label}']"))
+            expected_conditions.invisibility_of_element_located(
+                (By.XPATH, f"//*[@class='tag-label' and text()='{tag_label}']")
+            )
         )
         return True
     except TimeoutException:
@@ -103,7 +107,9 @@ def is_error_visible(driver: WebDriver):
 
     if saving_failed_hint and saving_failed_hint.is_displayed():
         WebDriverWait(driver, 10).until_not(
-            EC.invisibility_of_element_located((By.XPATH, "//div[contains(@class, 'task-dropper-content')]"))
+            expected_conditions.invisibility_of_element_located(
+                (By.XPATH, "//div[contains(@class, 'task-dropper-content')]")
+            )
         )
     return error_element is not None
 

wbcore/test/e2e_helpers_methods/e2e_helper_methods.py

@@ -4,7 +4,7 @@ from selenium.webdriver.common.action_chains import ActionChains
 from selenium.webdriver.common.by import By
 from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.remote.webelement import WebElement
-from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support import expected_conditions
 from selenium.webdriver.support.wait import WebDriverWait
 from wbcore import serializers as wb_serializers
 
@@ -157,7 +157,9 @@ def click_element_by_path(driver: WebDriver, xpath: str, wait_sec=WAIT_TIME_SEC)
         xpath (str): The xpath leading to the element.
     """
     try:
-        WebDriverWait(driver, wait_sec).until(EC.presence_of_element_located((By.XPATH, xpath))).click()
+        WebDriverWait(driver, wait_sec).until(
+            expected_conditions.presence_of_element_located((By.XPATH, xpath))
+        ).click()
     except TimeoutException:
         return []
 

wbcore/test/mixins.py

@@ -173,7 +173,7 @@ class ParentViewset:
             else get_model_factory(self.model)
         )
 
-    def _get_mixins_data(self, type="GET", dump_data=False, data=None):
+    def _get_mixins_data(self, type="GET", dump_data=False, data=None):  # noqa: C901
         api_request = APIRequestFactory()
         superuser = get_or_create_superuser()
         kwargs = None
@@ -307,34 +307,27 @@ class TestViewSet(ParentViewset):
                     kwargs["pk"] = obj.pk
             vs = self.mvs.as_view({"options": "options"})
             response = vs(request, **kwargs)
-            if ep.get_endpoint() or ep.get_list_endpoint():
-                assert response.status_code == status.HTTP_200_OK, (
-                    str(response.status_code) + f" == 200 ({response.data})"
-                )
-                assert response.data, str(response.data) + " should not be empty"
-                if "buttons" in response.data.keys():
-                    if "custom_instance" in response.data.get("buttons").keys():
-                        assert (
-                            list(response.data["buttons"]["custom_instance"])
-                            or len(list(response.data["buttons"]["custom_instance"])) == 0
-                        )
-                assert response.data.get("fields"), str(response.data.get("fields")) + " should not be None"
-                assert response.data.get("identifier"), str(response.data.get("identifier")) + " should not be None"
-                # assert response.data.get("pagination")
-                # assert response.data.get("pk")
-                # assert response.data.get("type")
-                # assert response.data.get("filterset_fields")
-                # assert response.data.get("search_fields")
-                # assert response.data.get("ordering_fields")
-                # assert response.data.get("buttons"), str(response.data.get("buttons")) + " should not be None"  # TODO: Refactor - buttons can be none
-                assert response.data.get("display"), str(response.data.get("display")) + " should not be None"
-                assert response.data.get("titles"), str(response.data.get("titles")) + " should not be None"
-                assert response.data.get("endpoints"), str(response.data.get("endpoints")) + " should not be None"
-                # assert response.data.get("preview")
-            else:
-                assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
-                    str(response.status_code) + f" == 405 ({response.data})"
-                )
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data, str(response.data) + " should not be empty"
+            if "buttons" in response.data.keys():
+                if "custom_instance" in response.data.get("buttons").keys():
+                    assert (
+                        list(response.data["buttons"]["custom_instance"])
+                        or len(list(response.data["buttons"]["custom_instance"])) == 0
+                    )
+            assert response.data.get("fields"), str(response.data.get("fields")) + " should not be None"
+            assert response.data.get("identifier"), str(response.data.get("identifier")) + " should not be None"
+            # assert response.data.get("pagination")
+            # assert response.data.get("pk")
+            # assert response.data.get("type")
+            # assert response.data.get("filterset_fields")
+            # assert response.data.get("search_fields")
+            # assert response.data.get("ordering_fields")
+            # assert response.data.get("buttons"), str(response.data.get("buttons")) + " should not be None"  # TODO: Refactor - buttons can be none
+            assert response.data.get("display"), str(response.data.get("display")) + " should not be None"
+            assert response.data.get("titles"), str(response.data.get("titles")) + " should not be None"
+            assert response.data.get("endpoints"), str(response.data.get("endpoints")) + " should not be None"
+            # assert response.data.get("preview")
             print(f"- {self.__class__.__name__}:test_option_request", colored("PASSED", "green"))  # noqa: T201
 
     # ----- LIST ROUTE TEST ----- #
@@ -346,16 +339,8 @@ class TestViewSet(ParentViewset):
             _, request, kwargs, _ = self._get_mixins_data("GET")
             vs = self.mvs.as_view({"get": "list"})
             response = vs(request, **kwargs)
-            ep = self._get_endpoint_config(request, kwargs)
-            if ep.get_endpoint() or ep.get_list_endpoint():
-                assert response.status_code == status.HTTP_200_OK, (
-                    str(response.status_code) + f" == 200 ({response.data})"
-                )
-                assert response.data, str(response.data) + " should not be empty"
-            else:
-                assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
-                    str(response.status_code) + f" == 405 ({response.data})"
-                )
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data, str(response.data) + " should not be empty"
             print(f"- {self.__class__.__name__}:test_get_request", colored("PASSED", "green"))  # noqa: T201
 
     # Test viewset "get": "list" -> aggregation
@@ -367,24 +352,16 @@ class TestViewSet(ParentViewset):
 
             vs = self.mvs.as_view({"get": "list"})
             response = vs(request, **kwargs)
-            ep = self._get_endpoint_config(request, kwargs)
-            if ep.get_endpoint() or ep.get_list_endpoint():
-                assert response.status_code == status.HTTP_200_OK, (
-                    str(response.status_code) + f" == 200 ({response.data})"
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data, str(response.data) + " should not be empty"
+            if not response.data.get("aggregates"):
+                print(  # noqa: T201
+                    f"- {self.__class__.__name__}:test_aggregation:" + self.mvs.__name__,
+                    colored("WARNING - aggregates not found in " + self.mvs.__name__, "yellow"),
                 )
-                assert response.data, str(response.data) + " should not be empty"
-                if not response.data.get("aggregates"):
-                    print(  # noqa: T201
-                        f"- {self.__class__.__name__}:test_aggregation:" + self.mvs.__name__,
-                        colored("WARNING - aggregates not found in " + self.mvs.__name__, "yellow"),
-                    )
-                else:
-                    if name_field:
-                        assert response.data.get("aggregates").get(name_field), name_field + "not found in aggregates"
             else:
-                assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
-                    str(response.status_code) + f" == 405 ({response.data})"
-                )
+                if name_field:
+                    assert response.data.get("aggregates").get(name_field), name_field + "not found in aggregates"
             print(f"- {self.__class__.__name__}:test_aggregation", colored("PASSED", "green"))  # noqa: T201
 
     # Test viewset "get": "list" with client and endpoint
@@ -398,16 +375,9 @@ class TestViewSet(ParentViewset):
             if ep.get_endpoint():
                 response = client.get(ep.get_endpoint())
             else:
-                response = client.get(ep.get_list_endpoint())
-            if ep.get_endpoint() or ep.get_list_endpoint():
-                assert response.status_code == status.HTTP_200_OK, (
-                    str(response.status_code) + f" == 200 ({response.data})"
-                )
-                assert response.data, str(response.data) + " should not be empty"
-            else:
-                assert response.status_code == status.HTTP_404_NOT_FOUND, (
-                    str(response.status_code) + f" == 404 ({response.data})"
-                )
+                response = client.get(ep._get_list_endpoint())
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data, str(response.data) + " should not be empty"
             print(f"- {self.__class__.__name__}:test_get_endpoint", colored("PASSED", "green"))  # noqa: T201
 
     # Test viewset "post": "create"
@@ -513,17 +483,12 @@ class TestViewSet(ParentViewset):
             obj, request, kwargs, _ = self._get_mixins_data("GET")
             vs = self.mvs.as_view({"get": "retrieve"})
             ep = self._get_endpoint_config(request, kwargs, obj)
-            ep_list = ep.get_list_endpoint()
             response = vs(request, **kwargs)
-            if ep_list:
+            if ep._get_instance_endpoint():
                 assert response.status_code == status.HTTP_200_OK, (
                     str(response.status_code) + f" == 200 ({response.data})"
                 )
                 assert response.data.get("instance"), str(response.data.get("instance")) + " should not be empty"
-            else:
-                assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
-                    str(response.status_code) + f" == 405 ({response.data})"
-                )
             print(f"- {self.__class__.__name__}:test_retrieve_request", colored("PASSED", "green"))  # noqa: T201
 
     # Test "delete": "destroy"
@@ -649,16 +614,8 @@ class TestPandasView(TestViewSet):
             _, request, kwargs, _ = self._get_mixins_data("GET")
             vs = self.mvs.as_view({"get": "list"})
             response = vs(request, **kwargs)
-            ep = self._get_endpoint_config(request, kwargs)
-            if ep.get_endpoint() or ep.get_list_endpoint():
-                assert response.status_code == status.HTTP_200_OK, (
-                    str(response.status_code) + f" == 200 ({response.data})"
-                )
-                assert response.data, str(response.data) + " should not be empty"
-            else:
-                assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
-                    str(response.status_code) + f" == 405 ({response.data})"
-                )
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data, str(response.data) + " should not be empty"
             print(f"- {self.__class__.__name__}:test_get_request", colored("PASSED", "green"))  # noqa: T201
 
     def execute_test(self):
@@ -681,27 +638,20 @@ class TestChartViewSet(TestViewSet):
 
             vs = self.mvs.as_view({"options": "options"})
             response = vs(request, **kwargs)
-            if ep.get_endpoint() or ep.get_list_endpoint():
-                assert response.status_code == status.HTTP_200_OK, (
-                    str(response.status_code) + f" == 200 ({response.data})"
-                )
-                assert response.data, str(response.data) + " should not be empty"
-                if "buttons" in response.data.keys():
-                    if "custom_instance" in response.data.get("buttons").keys():
-                        assert (
-                            list(response.data["buttons"]["custom_instance"])
-                            or len(list(response.data["buttons"]["custom_instance"])) == 0
-                        )
-                assert response.data.get("identifier"), str(response.data.get("identifier")) + " should not be None"
-                assert response.data.get("type") == "chart", "type of view should be chart"
-                assert response.data.get("buttons"), str(response.data.get("buttons")) + " should not be None"
-                assert response.data.get("display"), str(response.data.get("display")) + " should not be None"
-                assert response.data.get("titles"), str(response.data.get("titles")) + " should not be None"
-                assert response.data.get("endpoints"), str(response.data.get("endpoints")) + " should not be None"
-            else:
-                assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
-                    str(response.status_code) + f" == 405 ({response.data})"
-                )
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data, str(response.data) + " should not be empty"
+            if "buttons" in response.data.keys():
+                if "custom_instance" in response.data.get("buttons").keys():
+                    assert (
+                        list(response.data["buttons"]["custom_instance"])
+                        or len(list(response.data["buttons"]["custom_instance"])) == 0
+                    )
+            assert response.data.get("identifier"), str(response.data.get("identifier")) + " should not be None"
+            assert response.data.get("type") == "chart", "type of view should be chart"
+            assert response.data.get("buttons"), str(response.data.get("buttons")) + " should not be None"
+            assert response.data.get("display"), str(response.data.get("display")) + " should not be None"
+            assert response.data.get("titles"), str(response.data.get("titles")) + " should not be None"
+            assert response.data.get("endpoints"), str(response.data.get("endpoints")) + " should not be None"
             print(f"- {self.__class__.__name__}:test_option_request", colored("PASSED", "green"))  # noqa: T201
 
     def execute_test(self):