wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/currency/tests/test_viewsets.py

@@ -0,0 +1,197 @@
+from datetime import date, timedelta
+from decimal import Decimal
+
+import pytest
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.db.models import Q
+from django.forms.models import model_to_dict
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.currency.viewsets import (
+    CurrencyModelViewSet,
+    CurrencyRepresentationViewSet,
+)
+
+
+@pytest.mark.viewset_tests
+@pytest.mark.currency_representation_viewset_tests
+@pytest.mark.with_db
+@pytest.mark.django_db
+class TestCurrencyRepresentationViewSets:
+    @pytest.fixture()
+    def test_request(self):
+        factory = APIRequestFactory()
+        request = factory.get("")
+        request.user = SuperUserFactory()
+        return request
+
+    def test_currency_list_representation_viewset(self, test_request, currency_factory):
+        # Arrange
+        currency_factory.create_batch(2)
+        vs = CurrencyRepresentationViewSet.as_view({"get": "list"})
+        # Act
+        response = vs(test_request)
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        assert len(response.data["results"]) == 2
+
+    def test_currency_representation_viewset(self, test_request, currency_factory):
+        # Arrange
+        euro = currency_factory(symbol="€", key="EUR", title="Euro")
+        vs = CurrencyRepresentationViewSet.as_view({"get": "retrieve"})
+        # Act
+        response = vs(test_request, pk=euro.pk)
+        instance = response.data.get("instance")
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert instance.get("id") == euro.id
+        assert instance.get("key") == euro.key
+        assert instance.get("title") == euro.title
+
+
+@pytest.mark.viewset_tests
+@pytest.mark.currency_viewset_tests
+@pytest.mark.with_db
+@pytest.mark.django_db
+class TestCurrencyViewSets:
+    @pytest.fixture()
+    def api_rf(self):
+        factory = APIRequestFactory()
+        return factory
+
+    @pytest.fixture()
+    def su(self):
+        super_user = SuperUserFactory()
+        return super_user
+
+    @pytest.fixture()
+    def get_request(self, api_rf, su):
+        request = api_rf.get("")
+        request.user = su
+        return request
+
+    @pytest.fixture()
+    def currency(self):
+        currency = CurrencyFactory()
+        return currency
+
+    @pytest.fixture()
+    def currencies(self):
+        currency_a = CurrencyFactory()
+        currency_b = CurrencyFactory()
+        currency_c = CurrencyFactory()
+        return [currency_a, currency_b, currency_c]
+
+    def test_get_instance_request(self, get_request, currency):
+        # Arrange
+        vs = CurrencyModelViewSet.as_view({"get": "retrieve"})
+        # Act
+        response = vs(get_request, pk=currency.pk)
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert not response.data.get("results")
+        assert response.data["instance"]["id"] == currency.id
+
+    def test_get_list_request(self, get_request):
+        # Arrange
+        CurrencyFactory.create_batch(3)
+        vs = CurrencyModelViewSet.as_view({"get": "list"})
+        # Act
+        response = vs(get_request)
+        # Assert
+        results = response.data.get("results")
+        assert response.status_code == status.HTTP_200_OK
+        assert not response.data.get("instance")
+        assert len(results) == 3
+
+    def test_delete_instance(self, api_rf, su, currency):
+        # Arrange
+        request = api_rf.delete("")
+        request.user = su
+        view = CurrencyModelViewSet.as_view({"delete": "destroy"})
+        # Act
+        response = view(request, pk=currency.id)
+        # Assert
+        assert response.status_code == status.HTTP_204_NO_CONTENT
+        assert Currency.objects.count() == 0
+
+    def test_update_instance(self, api_rf, su, currency):
+        # Arrange
+        new_currency = model_to_dict(CurrencyFactory.build())
+        # Add missing values to the dict, because we cannot update data with 'None' values
+        new_currency["id"] = currency.id
+        new_currency["import_source"] = ""
+        request = api_rf.put("", data=new_currency)
+        request.user = su
+        view = CurrencyModelViewSet.as_view({"put": "update"})
+        # Act
+        response = view(request, pk=currency.id)
+        instance = response.data.get("instance")
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert instance["id"] == currency.id
+        assert instance["key"] == new_currency["key"]
+        assert instance["key"] != currency.key
+
+    @pytest.mark.parametrize("title", ["New_title"])
+    def test_patch_instance(self, api_rf, su, currency, title):
+        # Arrange
+        request = api_rf.patch("", data={"title": title})
+        request.user = su
+        # Act
+        view = CurrencyModelViewSet.as_view({"patch": "partial_update"})
+        response = view(request, pk=currency.id)
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["instance"]["title"] == title
+        assert currency.title != title
+        currency.refresh_from_db()  # The patch changes are only visible after a refresh
+        assert currency.title == title
+
+    def test_get_queryset_no_fx_rates(self, currencies):
+        viewset = CurrencyModelViewSet()
+        qs = viewset.get_queryset()
+        last_rate_date = date.today() - timedelta(days=30)
+        expected_queryset = Currency.objects.annotate(
+            fx_rates_date=ArrayAgg("fx_rates__date", filter=Q(fx_rates__date__gt=last_rate_date)),
+            fx_rates_value=ArrayAgg("fx_rates__value", filter=Q(fx_rates__date__gt=last_rate_date)),
+        )
+        assert list(qs) == list(expected_queryset)
+        for currency in qs:
+            assert currency.fx_rates_date is None
+            assert currency.fx_rates_value is None
+
+    def test_get_queryset_with_fx_rates(self, currencies):
+        recent_fx_rate_date, mid_fx_rate_date, past_cutoff_fx_rate_date = (
+            date.today() - timedelta(days=5),
+            date.today() - timedelta(days=20),
+            date.today() - timedelta(days=35),
+        )
+        value_a, value_b, value_c = (
+            Decimal("1.10"),
+            Decimal("0.85"),
+            Decimal("1.20"),
+        )
+
+        fx_rate_data = [
+            {"date": recent_fx_rate_date, "value": value_a},
+            {"date": mid_fx_rate_date, "value": value_b},
+            {"date": past_cutoff_fx_rate_date, "value": value_c},
+        ]
+
+        for currency in currencies:
+            for data in fx_rate_data:
+                CurrencyFXRatesFactory(currency=currency, date=data["date"], value=data["value"])
+
+        viewset = CurrencyModelViewSet()
+        qs = viewset.get_queryset()
+        expected_rates = [value_a, value_b]
+        expected_dates = [recent_fx_rate_date, mid_fx_rate_date]
+        assert len(qs) == 3
+        for currency in qs:
+            assert currency.fx_rates_date == expected_dates
+            assert currency.fx_rates_value == expected_rates

wbcore/contrib/currency/urls.py

@@ -0,0 +1,19 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from .viewsets import (
+    CurrencyFXRatesCurrencyModelViewSet,
+    CurrencyModelViewSet,
+    CurrencyRepresentationViewSet,
+)
+
+router = WBCoreRouter()
+router.register(r"currency", CurrencyModelViewSet, basename="currency")
+router.register(r"currencyrepresentation", CurrencyRepresentationViewSet, basename="currencyrepresentation")
+
+
+currency_router = WBCoreRouter()
+currency_router.register(r"currencyfxrates", CurrencyFXRatesCurrencyModelViewSet, basename="currency-currencyfxrates")
+
+
+urlpatterns = [path("", include(router.urls)), path("currency/<int:currency_id>/", include(currency_router.urls))]

wbcore/contrib/currency/viewsets/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyModelViewSet, CurrencyRepresentationViewSet
+from .currency_fx_rates import CurrencyFXRatesCurrencyModelViewSet

wbcore/contrib/currency/viewsets/currency.py

@@ -0,0 +1,56 @@
+from datetime import date, timedelta
+
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.db.models import Q
+from rest_framework import filters
+from wbcore import viewsets
+from wbcore.filters import DjangoFilterBackend
+
+from ..models import Currency, CurrencyFXRates
+from ..serializers import CurrencyModelSerializer, CurrencyRepresentationSerializer
+from .display import CurrencyDisplayConfig
+from .preview import CurrencyPreviewConfig
+from .titles import CurrencyTitleConfig
+
+
+class CurrencyRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Currency.objects.all()
+    serializer_class = CurrencyRepresentationSerializer
+    filter_backends = (filters.OrderingFilter, filters.SearchFilter)
+
+    ordering = ordering_fields = ["-symbol"]
+    search_fields = ("symbol", "key")
+
+
+class CurrencyModelViewSet(viewsets.ModelViewSet):
+    display_config_class = CurrencyDisplayConfig
+    title_config_class = CurrencyTitleConfig
+    preview_config_class = CurrencyPreviewConfig
+
+    queryset = Currency.objects.all()
+    serializer_class = CurrencyModelSerializer
+
+    filter_backends = (DjangoFilterBackend, filters.OrderingFilter)
+
+    filterset_fields = {
+        "title": ["exact", "icontains"],
+        "symbol": ["exact", "icontains"],
+        "key": ["exact", "icontains"],
+    }
+    ordering_fields = ("title", "symbol", "key")
+
+    ordering = ["title"]
+
+    def get_queryset(self):
+        last_rate_date = date.today()
+        if CurrencyFXRates.objects.exists():
+            last_rate_date = CurrencyFXRates.objects.latest("date").date
+        last_rate_date -= timedelta(days=30)
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                fx_rates_date=ArrayAgg("fx_rates__date", filter=Q(fx_rates__date__gt=last_rate_date)),
+                fx_rates_value=ArrayAgg("fx_rates__value", filter=Q(fx_rates__date__gt=last_rate_date)),
+            )
+        )

wbcore/contrib/currency/viewsets/currency_fx_rates.py

@@ -0,0 +1,32 @@
+from rest_framework import filters
+from wbcore import viewsets
+from wbcore.filters import DjangoFilterBackend
+
+from ..models import CurrencyFXRates
+from ..serializers import CurrencyFXRatesModelSerializer
+from .display import CurrencyFXRatesCurrencyDisplayConfig
+from .endpoints import CurrencyFXRatesCurrencyEndpointConfig
+from .titles import CurrencyFXRatesCurrencyTitleConfig
+
+
+class CurrencyFXRatesCurrencyModelViewSet(viewsets.ModelViewSet):
+    display_config_class = CurrencyFXRatesCurrencyDisplayConfig
+    endpoint_config_class = CurrencyFXRatesCurrencyEndpointConfig
+    title_config_class = CurrencyFXRatesCurrencyTitleConfig
+
+    serializer_class = CurrencyFXRatesModelSerializer
+    filter_backends = (filters.OrderingFilter, DjangoFilterBackend)
+
+    ordering = ordering_fields = ["-date"]
+
+    filter_backends = (DjangoFilterBackend, filters.OrderingFilter)
+    queryset = CurrencyFXRates.objects.all()
+
+    filterset_fields = {"date": ["gte", "exact", "lte"], "value": ["gte", "exact", "lte"]}
+    ordering_fields = ("date", "value")
+
+    ordering = ["-date"]
+
+    def get_queryset(self):
+        _id = self.kwargs["currency_id"]
+        return CurrencyFXRates.objects.filter(currency__id=_id).all()

wbcore/contrib/currency/viewsets/display/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyDisplayConfig
+from .currency_fx_rates import CurrencyFXRatesCurrencyDisplayConfig

wbcore/contrib/currency/viewsets/display/currency.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+from django.utils.translation import gettext_lazy as _
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class CurrencyDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="symbol", label="Sybmol"),
+                dp.Field(key="key", label="Key"),
+                dp.Field(key="rates_sparkline", label="Rates"),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [["title", "symbol", "key"], [repeat_field(3, "currencyfxrates_section")]],
+            [
+                create_simple_section(
+                    "currencyfxrates_section",
+                    _("Rates"),
+                    [["currency_currencyfxrates"]],
+                    "currency_currencyfxrates",
+                    collapsed=False,
+                )
+            ],
+        )

wbcore/contrib/currency/viewsets/display/currency_fx_rates.py

@@ -0,0 +1,9 @@
+from typing import Optional
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class CurrencyFXRatesCurrencyDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(fields=[dp.Field(key="date", label="Date"), dp.Field(key="value", label="Value")])

wbcore/contrib/currency/viewsets/endpoints/__init__.py

@@ -0,0 +1 @@
+from .currency_fx_rates import CurrencyFXRatesCurrencyEndpointConfig

wbcore/contrib/currency/viewsets/endpoints/currency_fx_rates.py

@@ -0,0 +1,14 @@
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class CurrencyFXRatesCurrencyEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None
+
+    def get_list_endpoint(self, **kwargs):
+        return reverse(
+            "wbcore:currency:currency-currencyfxrates-list",
+            args=[self.view.kwargs["currency_id"]],
+            request=self.request,
+        )

wbcore/contrib/currency/viewsets/menu/__init__.py

@@ -0,0 +1 @@
+from .currency import CURRENCY_MENUITEM

wbcore/contrib/currency/viewsets/menu/currency.py

@@ -0,0 +1,8 @@
+from wbcore.menus import ItemPermission, MenuItem
+
+CURRENCY_MENUITEM = MenuItem(
+    label="Currency",
+    endpoint="wbcore:currency:currency-list",
+    add=MenuItem(label="New Currency", endpoint="wbcore:currency:currency-list"),
+    permission=ItemPermission(method=lambda request: request.user.is_staff),
+)

wbcore/contrib/currency/viewsets/preview/__init__.py

@@ -0,0 +1 @@
+from .currency import CurrencyPreviewConfig

wbcore/contrib/currency/viewsets/preview/currency.py

@@ -0,0 +1,10 @@
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.preview import PreviewViewConfig
+
+
+class CurrencyPreviewConfig(PreviewViewConfig):
+    def get_display(self) -> Display:
+        return create_simple_display([["title", "symbol", "key"]])

wbcore/contrib/currency/viewsets/titles/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyTitleConfig
+from .currency_fx_rates import CurrencyFXRatesCurrencyTitleConfig

wbcore/contrib/currency/viewsets/titles/currency.py

@@ -0,0 +1,6 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class CurrencyTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        return "{{key}} ({{symbol}})"

wbcore/contrib/currency/viewsets/titles/currency_fx_rates.py

@@ -0,0 +1,8 @@
+from wbcore.contrib.currency.models import Currency
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class CurrencyFXRatesCurrencyTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        currency = Currency.objects.get(id=self.view.kwargs["currency_id"])
+        return f"Rates for {currency.key} ({currency.symbol})"

wbcore/contrib/dataloader/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbcore/contrib/dataloader/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class WBDataAppConfig(AppConfig):
+    name = "wbcore.contrib.dataloader"

wbcore/contrib/dataloader/dataloaders/__init__.py

@@ -0,0 +1,2 @@
+from .dataloaders import Dataloader
+from .proxies import DataloaderProxy

wbcore/contrib/dataloader/dataloaders/dataloaders.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING, Generator
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+    from wbcore.contrib.dataloader.models.entities import Entity
+
+
+class Dataloader:
+    """Base class for dataloaders, providing a foundational structure for subclasses.
+
+    This class includes an attribute `entities`, which is a Django queryset of Entity objects.
+    It is designed to be subclassed by other classes which will implement specific methods.
+
+    Attributes:
+        entities (QuerySet[Entity]): A Django queryset of Entity objects.
+    """
+
+    def __init__(self, entities: "QuerySet[Entity]"):
+        self.entities = entities
+        super().__init__()
+
+    @property
+    def entity_ids(self) -> Generator[int, None, None]:
+        return self.entities.values_list("id", flat=True)

wbcore/contrib/dataloader/dataloaders/proxies.py

@@ -0,0 +1,81 @@
+from contextlib import suppress
+from typing import TYPE_CHECKING, Generic, Iterator, Type, TypeVar
+
+from django.utils.module_loading import import_string
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+    from wbcore.contrib.dataloader.dataloaders import Dataloader
+    from wbcore.contrib.dataloader.models import Entity
+
+
+T = TypeVar("T")
+
+
+class DataloaderProxy(Generic[T]):
+    """Manages and facilitates data loading from remote resources using dataloaders.
+
+    This class serves as a proxy for various dataloader instances. Each dataloader is
+    a subclass of `Dataloader`, designed to fetch data from a remote resource. The
+    `DataloaderProxy` class enables the splicing of a queryset into parts, where each
+    part uses a specific dataloader, thus abstracting the complexity of data fetching
+    from multiple sources.
+
+    The key responsibility of this class includes:
+    - Splicing a queryset into segments, ensuring each segment uses the corresponding dataloader.
+    - Providing an external interface to interact with different dataloaders, which allows
+      for efficient data retrieval and processing.
+
+    To utilize this class, it should be subclassed and associated with a Django model
+    that can be processed by the `Dataloader` subclasses. This setup facilitates the
+    dynamic and efficient retrieval of data, tailored to the specific needs of the application.
+
+    Attributes:
+        queryset (QuerySet[Entity]): A Django queryset that represents a collection of
+            entities to be processed by the dataloaders.
+    """
+
+    def __init__(self, queryset: "QuerySet[Entity]"):
+        self.queryset = queryset
+
+    @staticmethod
+    def load_dataloader(path: str) -> Type["Dataloader"]:
+        """Loads a Dataloader object from a given path.
+
+        This static method imports a Dataloader class from the specified path string.
+
+        Args:
+            path (str): The dot-delimited path to the Dataloader class to be imported.
+                For example, 'module.submodule.ClassName'.
+
+        Returns:
+            Type["Dataloader"]: An instance of the Dataloader class loaded from the given path.
+
+        Raises:
+            ImportError: If the path does not correspond to a valid class.
+        """
+        return import_string(path)
+
+    def iterate_dataloaders(self, dl_name: str) -> Iterator[T]:
+        """Iterates over distinct dataloaders specified by a given name.
+
+        This method retrieves a distinct list of paths associated with the specified
+        dataloader name, then iterates over these paths. For each path, it loads a
+        dataloader instance and filters the queryset based on the path, then yields
+        this dataloader.
+
+        The type `T` represents the specific type of the dataloaders that will be loaded and
+        iterated over.
+
+        Args:
+            dl_name (str): The name of the dataloader to be iterated over. This name
+                is used to construct the path key for querying distinct dataloader paths.
+
+        Returns:
+            Iterator[T]: An iterator of dataloader instances of the generic type `T` corresponding
+            to each distinct path found in the queryset.
+        """
+        dl_path = f"dl_parameters__{dl_name}__path"
+        for path in self.queryset.distinct(dl_path).values_list(dl_path, flat=True):
+            with suppress(AttributeError):
+                yield self.load_dataloader(path)(self.queryset.filter(**{dl_path: path}))

wbcore/contrib/dataloader/models/__init__.py

@@ -0,0 +1 @@
+from .entities import Entity

wbcore/contrib/dataloader/models/entities.py

@@ -0,0 +1,29 @@
+from django.db import models
+from wbcore.contrib.dataloader.dataloaders import DataloaderProxy
+from wbcore.contrib.dataloader.models.querysets import EntityQuerySet
+
+
+class Entity(models.Model):
+    """An abstract model representing an entity with associated dataloaders.
+
+    This model serves as a base for entities that store data and have dataloaders
+    attached for data retrieval and processing. It includes specialized fields to
+    facilitate the use of dataloaders:
+
+    Attributes:
+        dl_proxy (DataloaderProxy): A reference to the DataloaderProxy. This should be
+            set when using this model to manage the associated dataloaders.
+        dl_parameters (models.JSONField): A field to store parameters for various
+            dataloaders. It is structured in the format:
+            `{"dataloader_name": {"path": "path.to.dataloader", "parameters": {}}}`.
+        objects (EntityQuerySet): A custom model manager providing an interface to a
+            dataloader proxy. This proxy can be accessed through the 'dl' method on a
+            queryset, e.g., `Entity.objects.all().dl`.
+    """
+
+    dl_proxy: DataloaderProxy
+    dl_parameters = models.JSONField(default=dict, blank=True)
+    objects = EntityQuerySet.as_manager()
+
+    class Meta:
+        abstract = True

wbcore/contrib/dataloader/models/querysets/__init__.py

@@ -0,0 +1 @@
+from .entities import EntityQuerySet

wbcore/contrib/dataloader/models/querysets/entities.py

@@ -0,0 +1,27 @@
+from django.db import models
+from wbcore.contrib.dataloader.dataloaders.proxies import DataloaderProxy
+
+
+class EntityQuerySet(models.QuerySet):
+    """A custom QuerySet for entities that provides an interface to a dataloader proxy.
+
+    This QuerySet subclass adds a method to interact with the associated dataloader
+    proxy. It is designed to be used with models that inherit from the `Entity` class,
+    providing a streamlined way to access dataloader functionality directly from
+    QuerySet instances.
+    """
+
+    @property
+    def dl(self) -> DataloaderProxy:
+        """Provides access to the dataloader proxy for the entities in the QuerySet.
+
+        This method allows for easy retrieval of the DataloaderProxy instance
+        associated with the QuerySet. It enables the utilization of dataloader
+        functionalities directly from the QuerySet, facilitating data fetching and
+        processing tasks.
+
+        Returns:
+            DataloaderProxy: An instance of DataloaderProxy associated with the
+                entities in the QuerySet.
+        """
+        return self.model.dl_proxy(self)

wbcore/contrib/dataloader/tests/conftest.py

@@ -0,0 +1,26 @@
+from django.db import connection
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+
+from .test.factories import EntityTestFactory
+
+
+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;")
+
+
+pre_migrate.connect(app_pre_migration)
+register(EntityTestFactory)
+register(
+    EntityTestFactory,
+    "entity_test_over_1000",
+    dl_parameters={
+        "data": {
+            "path": "wbcore.contrib.dataloader.tests.test.dataloaders.dataloaders.RandomDataOver1000",
+            "parameters": {},
+        }
+    },
+)