added core handler methods to modify the applications

backend/src/baserow/api/v0/__init__.py

@@ -1 +1 @@
-app_name = 'baserow.api.v0'
+default_app_config = 'baserow.api.v0.config.ApiConfig'

backend/src/baserow/api/v0/applications/urls.py

@@ -0,0 +1,8 @@
+from django.conf.urls import url
+
+
+app_name = 'baserow.api.v0.group'
+
+urlpatterns = [
+
+]

backend/src/baserow/api/v0/decorators.py

@@ -3,7 +3,8 @@ from rest_framework.exceptions import APIException
 
 
 def map_exceptions(exceptions):
-    """This decorator easily maps specific exceptions to a standard api response.
+    """
+    This decorator simplifies mapping specific exceptions to a standard api response.
 
     Example:
       @map_exceptions({ SomeException: 'ERROR_1' })

backend/src/baserow/api/v0/urls.py

@@ -1,12 +1,16 @@
 from django.urls import path, include
 
+from baserow.core.applications import registry
+
 from .user import urls as user_urls
 from .groups import urls as group_urls
+from .applications import urls as application_urls
 
 
 app_name = 'baserow.api.v0'
 
 urlpatterns = [
     path('user/', include(user_urls, namespace='user')),
-    path('groups/', include(group_urls, namespace='groups'))
-]
+    path('groups/', include(group_urls, namespace='groups')),
+    path('applications/', include(application_urls, namespace='applications'))
+] + registry.api_urls

backend/src/baserow/api/v0/user/errors.py

@@ -0,0 +1 @@
+ERROR_ALREADY_EXISTS = 'ERROR_ALREADY_EXISTS'

backend/src/baserow/api/v0/user/views.py

@@ -9,8 +9,8 @@ from baserow.api.v0.decorators import map_exceptions
 from baserow.user.handler import UserHandler
 from baserow.user.exceptions import UserAlreadyExist
 
-
 from .serializers import RegisterSerializer, UserSerializer
+from .errors import ERROR_ALREADY_EXISTS
 
 
 jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
@@ -23,7 +23,7 @@ class UserView(APIView):
 
     @transaction.atomic
     @map_exceptions({
-        UserAlreadyExist: 'ERROR_ALREADY_EXISTS'
+        UserAlreadyExist: ERROR_ALREADY_EXISTS
     })
     def post(self, request):
         serializer = RegisterSerializer(data=request.data)

backend/src/baserow/config/settings/base.py

@@ -26,7 +26,8 @@ INSTALLED_APPS = [
     'corsheaders',
 
     'baserow.core',
-    'baserow.api.v0'
+    'baserow.api.v0',
+    'baserow.contrib.database'
 ]
 
 MIDDLEWARE = [

backend/src/baserow/contrib/database/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'baserow.contrib.database.config.DatabaseConfig'

backend/src/baserow/contrib/database/api_urls.py

@@ -0,0 +1,8 @@
+from django.conf.urls import url
+
+
+app_name = 'baserow.contrib.database'
+
+urlpatterns = [
+
+]

backend/src/baserow/contrib/database/applications.py

@@ -0,0 +1,16 @@
+from django.urls import path, include
+
+from baserow.core.applications import Application
+
+from . import api_urls
+from .models import Database
+
+
+class DatabaseApplication(Application):
+    type = 'database'
+    instance_model = Database
+
+    def get_api_urls(self):
+        return [
+            path('database/', include(api_urls, namespace=self.type)),
+        ]

backend/src/baserow/contrib/database/config.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+
+from baserow.core.applications import registry
+
+
+class DatabaseConfig(AppConfig):
+    name = 'baserow.contrib.database'
+
+    def ready(self):
+        from .applications import DatabaseApplication
+        registry.register(DatabaseApplication())

backend/src/baserow/contrib/database/models.py

@@ -0,0 +1,12 @@
+from django.db import models
+
+from baserow.core.models import Application
+
+
+class Database(Application):
+    pass
+
+
+class Table(models.Model):
+    group = models.ForeignKey(Database, on_delete=models.CASCADE)
+    order = models.PositiveIntegerField()

backend/src/baserow/core/__init__.py

@@ -1 +1 @@
-app_name = 'baserow.group'
+default_app_config = 'baserow.core.config.CoreConfig'

backend/src/baserow/core/applications.py

@@ -0,0 +1,138 @@
+from django.core.exceptions import ImproperlyConfigured
+
+from .exceptions import ApplicationAlreadyRegistered, ApplicationTypeDoesNotExist
+
+
+class Application(object):
+    """
+    This abstract class represents a custom application that can be added to the
+    application registry. It must be extended so customisation can be done. Each
+    application will have his own model that must extend the ApplicationModel, this is
+    needed to that the user can set custom settings per application instance he has
+    created.
+
+    Example:
+        from baserow.core.models import ApplicationModel
+        from baserow.core.applications import Application, registry
+
+        class ExampleApplicationModel(ApplicationModel):
+            pass
+
+        class ExampleApplication(Application):
+            type = 'a-unique-type-name'
+            instance_model = ExampleApplicationModel
+
+        registry.register(ExampleApplication())
+
+    """
+
+    type = None
+    instance_model = None
+
+    def __init__(self):
+        if not self.type:
+            raise ImproperlyConfigured('The type of an application must be set.')
+
+        if not self.instance_model:
+            raise ImproperlyConfigured('The instance model of an application must be '
+                                       'set.')
+
+    def get_api_urls(self):
+        """
+        If needed custom api related urls to the application can be added here.
+
+        Example:
+
+            def get_api_urls(self):
+                from . import api_urls
+
+                return [
+                    path('some-application/', include(api_urls, namespace=self.type)),
+                ]
+
+            # api_urls.py
+            from django.conf.urls import url
+
+            urlpatterns = [
+              url(r'some-view^$', SomeView.as_view(), name='some_view'),
+            ]
+
+        :return: A list containing the urls.
+        :rtype: list
+        """
+        return []
+
+
+class ApplicationRegistry(object):
+    """
+    With the application registry it is possible to register new applications.  An
+    application is an abstraction made specifically for Baserow. If added to the
+    registry a user can create new instances of that application via the ap and register
+    api related urls.
+    """
+
+    def __init__(self):
+        self.registry = {}
+
+    def get(self, type):
+        """
+        Returns a registered application their type name.
+
+        :param type: The type name of the registered application.
+        :param type: str
+        :return: The requested application.
+        :rtype: Application
+        """
+
+        if type not in self.registry:
+            raise ApplicationTypeDoesNotExist(f'The application type {type} does not '
+                                              f'exist.')
+
+        return self.registry[type]
+
+    def register(self, application):
+        """
+        Registers a new application in the registry.
+
+        :param application: The application that needs to be registered.
+        :type application:
+        """
+
+        if not isinstance(application, Application):
+            raise ValueError('The application must be an instance of Application.')
+
+        if application.type in self.registry:
+            raise ApplicationAlreadyRegistered(
+                f'The application with type {application.type} is already registered.')
+
+        self.registry[application.type] = application
+
+    def unregister(self, value):
+        if isinstance(value, Application):
+            for type, application in self.registry.items():
+                if application == value:
+                    value = type
+
+        if isinstance(value, str):
+            del self.registry[value]
+        else:
+            raise ValueError('The value must either be an application instance or type '
+                             'name')
+
+    @property
+    def api_urls(self):
+        """
+        Returns a list of all the api urls that are in the registered applications.
+
+        :return: The api urls of the registered applications.
+        :rtype: list
+        """
+        api_urls = []
+        for application in self.registry.values():
+            api_urls += application.get_api_urls()
+        return api_urls
+
+
+# A default application is created here, this is the one that is used throughout the
+# whole Baserow application. To add a new application use this registry.
+registry = ApplicationRegistry()

backend/src/baserow/core/config.py

@@ -1,5 +1,5 @@
 from django.apps import AppConfig
 
 
-class ApiConfig(AppConfig):
+class CoreConfig(AppConfig):
     name = 'baserow.core'

backend/src/baserow/core/exceptions.py

@@ -1,2 +1,10 @@
 class UserNotIngroupError(Exception):
     pass
+
+
+class ApplicationAlreadyRegistered(Exception):
+    pass
+
+
+class ApplicationTypeDoesNotExist(Exception):
+    pass

backend/src/baserow/core/handler.py

@@ -1,10 +1,13 @@
-from .models import Group, GroupUser
+from .models import Group, GroupUser, Application
 from .exceptions import UserNotIngroupError
+from .utils import extract_allowed, set_allowed_attrs
+from .applications import registry
 
 
 class CoreHandler:
     def create_group(self, user, **kwargs):
-        """Creates a new group for an existing user.
+        """
+        Creates a new group for an existing user.
 
         :param user: The user that must be in the group.
         :type user: User
@@ -12,13 +15,7 @@ class CoreHandler:
         :rtype: GroupUser
         """
 
-        allowed_fields = ['name']
-
-        group_values = {}
-        for field in allowed_fields:
-            if field in allowed_fields:
-                group_values[field] = kwargs[field]
-
+        group_values = extract_allowed(kwargs, ['name'])
         group = Group.objects.create(**group_values)
         last_order = GroupUser.get_last_order(user)
         group_user = GroupUser.objects.create(group=group, user=user, order=last_order)
@@ -26,36 +23,41 @@ class CoreHandler:
         return group_user
 
     def update_group(self, user, group, **kwargs):
-        """Updates fields of a group.
-
-        :param user:
-        :param group:
-        :return:
         """
+        Updates the values of a group.
+
+        :param user: The user on whose behalf the change is made.
+        :type user: User
+        :param group: The group instance that must be updated.
+        :type group: Group
+        :return: The updated group
+        :rtype: Group
+        """
+
+        if not isinstance(group, Group):
+            raise ValueError('The group is not an instance of Group.')
 
         if not group.has_user(user):
             raise UserNotIngroupError(f'The user {user} does not belong to the group '
                                       f'{group}.')
 
-        allowed_fields = ['name']
-
-        for field in allowed_fields:
-            if field in kwargs:
-                setattr(group, field, kwargs[field])
-
+        group = set_allowed_attrs(kwargs, ['name'], group)
         group.save()
 
         return group
 
     def delete_group(self, user, group):
-        """Deletes an existing group.
-
-        :param user:
-        :type: user: User
-        :param group:
-        :type: group: Group
-        :return:
         """
+        Deletes an existing group.
+
+        :param user: The user on whose behalf the delete is done.
+        :type: user: User
+        :param group: The group instance that must be deleted.
+        :type: group: Group
+        """
+
+        if not isinstance(group, Group):
+            raise ValueError('The group is not an instance of Group.')
 
         if not group.has_user(user):
             raise UserNotIngroupError(f'The user {user} does not belong to the group '
@@ -64,9 +66,10 @@ class CoreHandler:
         group.delete()
 
     def order_groups(self, user, group_ids):
-        """Changes the order of groups for a user.
+        """
+        Changes the order of groups for a user.
 
-        :param user:
+        :param user: The user on whose behalf the ordering is done.
         :type: user: User
         :param group_ids: A list of group ids ordered the way they need to be ordered.
         :type group_ids: List[int]
@@ -77,3 +80,81 @@ class CoreHandler:
                 user=user,
                 group_id=group_id
             ).update(order=index + 1)
+
+    def create_application(self, user, group, type, **kwargs):
+        """
+        Creates a new application based on the provided type.
+
+        :param user: The user on whose behalf the application is created.
+        :type user: User
+        :param group: The group that the application instance belongs to.
+        :type group: Group
+        :param type: The type name of the application. Application can be registered via
+                     the ApplicationRegistry.
+        :type type: str
+        :param kwargs: The fields that need to be set upon creation.
+        :type kwargs: object
+        :return: The created application instance.
+        :rtype: Application
+        """
+
+        if not group.has_user(user):
+            raise UserNotIngroupError(f'The user {user} does not belong to the group '
+                                      f'{group}.')
+
+        # Figure out which model is used for the given application type.
+        application = registry.get(type)
+        model = application.instance_model
+        application_values = extract_allowed(kwargs, ['name'])
+
+        if 'order' not in application_values:
+            application_values['order'] = model.get_last_order(group)
+
+        instance = model.objects.create(group=group, **application_values)
+
+        return instance
+
+    def update_application(self, user, application, **kwargs):
+        """
+        Updates an existing application instance.
+
+        :param user: The user on whose behalf the application is updated.
+        :type user: User
+        :param application: The application instance that needs to be updated.
+        :type application: Application
+        :param kwargs: The fields that need to be updated.
+        :type kwargs: object
+        :return: The updated application instance.
+        :rtype: Application
+        """
+
+        if not isinstance(application, Application):
+            raise ValueError('The application is not an instance of Application')
+
+        if not application.group.has_user(user):
+            raise UserNotIngroupError(f'The user {user} does not belong to the group '
+                                      f'{application.group}.')
+
+        application = set_allowed_attrs(kwargs, ['name'], application)
+        application.save()
+
+        return application
+
+    def delete_application(self, user, application):
+        """
+        Deletes an existing application instance.
+
+        :param user: The user on whose behalf the application is deleted.
+        :type user: User
+        :param application: The application instance that needs to be deleted.
+        :type application: Application
+        """
+
+        if not isinstance(application, Application):
+            raise ValueError('The application is not an instance of Application')
+
+        if not application.group.has_user(user):
+            raise UserNotIngroupError(f'The user {user} does not belong to the group '
+                                      f'{application.group}.')
+
+        application.delete()

backend/src/baserow/core/mixins.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+
+class OrderableMixin:
+    """
+    This mixin introduces a set of helpers of the model is orderable by a field.
+    """
+
+    @classmethod
+    def get_highest_order_of_queryset(cls, queryset, field='order'):
+        """
+
+        :param queryset:
+        :param field:
+        :return:
+        """
+        return queryset.aggregate(
+            models.Max(field)
+        ).get(f'{field}__max', 0) or 0

backend/src/baserow/core/models.py

@@ -1,12 +1,18 @@
 from django.db import models
 from django.contrib.auth import get_user_model
+from django.contrib.contenttypes.models import ContentType
 
 from .managers import GroupQuerySet
+from .mixins import OrderableMixin
 
 
 User = get_user_model()
 
 
+def get_default_application_content_type():
+    return ContentType.objects.get_for_model(Application)
+
+
 class Group(models.Model):
     name = models.CharField(max_length=100)
     users = models.ManyToManyField(User, through='GroupUser')
@@ -21,7 +27,7 @@ class Group(models.Model):
         return f'<Group id={self.id}, name={self.name}>'
 
 
-class GroupUser(models.Model):
+class GroupUser(OrderableMixin, models.Model):
     user = models.ForeignKey(User, on_delete=models.CASCADE)
     group = models.ForeignKey(Group, on_delete=models.CASCADE)
     order = models.PositiveIntegerField()
@@ -31,11 +37,28 @@ class GroupUser(models.Model):
 
     @classmethod
     def get_last_order(cls, user):
-        """Returns a new position that will be last for a new group."""
-        highest_order = cls.objects.filter(
-            user=user
-        ).aggregate(
-            models.Max('order')
-        ).get('order__max', 0) or 0
+        return cls.get_highest_order_of_queryset(cls.objects.filter(user=user)) + 1
 
-        return highest_order + 1
+
+class Application(OrderableMixin, models.Model):
+    group = models.ForeignKey(Group, on_delete=models.CASCADE)
+    name = models.CharField(max_length=50)
+    order = models.PositiveIntegerField()
+    content_type = models.ForeignKey(
+        ContentType,
+        verbose_name='content type',
+        related_name='applications',
+        on_delete=models.SET(get_default_application_content_type)
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if not self.id:
+            if not self.content_type_id:
+                self.content_type = ContentType.objects.get_for_model(self)
+
+    @classmethod
+    def get_last_order(cls, group):
+        return cls.get_highest_order_of_queryset(
+            Application.objects.filter(group=group)) + 1

backend/src/baserow/core/utils.py

@@ -0,0 +1,67 @@
+def extract_allowed(values, allowed_fields):
+    """
+    Returns a new dict with the values of the key names that are in the allowed_fields.
+    The other keys are ignored.
+
+    Example:
+        object_1 = {
+            'value_1': 'value',
+            'value_2': 'value'
+        }
+
+        extract_allowed(object_1, ['value_1'])
+        >> {'value_1': 'value'}
+
+    :param values: A dict containing the values.
+    :type dict:
+    :param allowed_fields: A list containing the keys of the values that need to be
+                           extracted from the values.
+    :type allowed_fields: list
+    :return: The extracted values.
+    :rtype: dict
+    """
+
+    allowed_values = {}
+    for field in allowed_fields:
+        if field in values:
+            allowed_values[field] = values[field]
+
+    return allowed_values
+
+
+def set_allowed_attrs(values, allowed_fields, instance):
+    """
+    Sets the attributes of the instance with the values of the key names that are in the
+    allowed_fields. The other keys are ignored.
+
+    Examples:
+        class Tmp(object):
+            value_1 = 'value'
+            value_2 = 'value'
+
+        object_1 = {
+            'value_1': 'value_2',
+            'value_2': 'value_2'
+        }
+
+        tmp = set_allowed_attrs(object_1, ['value_1'], Tmp())
+        tmp.value_1
+        >> 'value_2'
+        tmp.value_2
+        >> 'value'
+
+    :param values: The dict containing the values.
+    :type values: dict
+    :param allowed_fields: A list containing the keys of the value that need to be set
+                           on the instance.
+    :type allowed_fields: list
+    :param instance: The instance of which the attributes must be updated.
+    :type instance: object
+    :return: The updated instance.
+    """
+
+    for field in allowed_fields:
+        if field in values:
+            setattr(instance, field, values[field])
+
+    return instance

backend/tests/baserow/api/v0/test_api_decorators.py

@@ -0,0 +1,46 @@
+import pytest
+
+from rest_framework import status
+from rest_framework.exceptions import APIException
+
+from baserow.api.v0.decorators import map_exceptions
+
+
+class TemporaryException(Exception):
+    pass
+
+
+def test_map_exceptions():
+    @map_exceptions({
+        TemporaryException: 'ERROR_TEMPORARY'
+    })
+    def test_1():
+        raise TemporaryException
+
+    with pytest.raises(APIException) as api_exception_1:
+        test_1()
+
+    assert api_exception_1.value.detail['error'] == 'ERROR_TEMPORARY'
+    assert api_exception_1.value.detail['detail'] == ''
+    assert api_exception_1.value.status_code == status.HTTP_400_BAD_REQUEST
+
+    @map_exceptions({
+        TemporaryException: ('ERROR_TEMPORARY_2', 404, 'Another message')
+    })
+    def test_2():
+        raise TemporaryException
+
+    with pytest.raises(APIException) as api_exception_2:
+        test_2()
+
+    assert api_exception_2.value.detail['error'] == 'ERROR_TEMPORARY_2'
+    assert api_exception_2.value.detail['detail'] == 'Another message'
+    assert api_exception_2.value.status_code == status.HTTP_404_NOT_FOUND
+
+    @map_exceptions({
+        TemporaryException: 'ERROR_TEMPORARY_3'
+    })
+    def test_3():
+        pass
+
+    test_3()

backend/tests/baserow/core/test_core_applications.py

@@ -0,0 +1,44 @@
+import pytest
+
+from baserow.core.applications import Application, ApplicationRegistry
+from baserow.core.exceptions import ApplicationAlreadyRegistered
+
+
+class TemporaryApplication1(Application):
+    type = 'temporary_1'
+    instance_model = object
+
+
+class TemporaryApplication2(Application):
+    type = 'temporary_2'
+    instance_model = object
+
+
+def test_application_registry_register():
+    temporary_1 = TemporaryApplication1()
+    temporary_2 = TemporaryApplication2()
+
+    registry = ApplicationRegistry()
+    registry.register(temporary_1)
+    registry.register(temporary_2)
+
+    with pytest.raises(ValueError):
+        registry.register('NOT AN APPLICATION')
+
+    with pytest.raises(ApplicationAlreadyRegistered):
+        registry.register(temporary_1)
+
+    assert len(registry.registry.items()) == 2
+    assert registry.registry['temporary_1'] == temporary_1
+    assert registry.registry['temporary_2'] == temporary_2
+
+    registry.unregister(temporary_1)
+
+    assert len(registry.registry.items()) == 1
+
+    registry.unregister('temporary_2')
+
+    assert len(registry.registry.items()) == 0
+
+    with pytest.raises(ValueError):
+        registry.unregister(000)

backend/tests/baserow/core/test_core_handler.py

@@ -1,8 +1,9 @@
 import pytest
 
 from baserow.core.handler import CoreHandler
-from baserow.core.models import Group, GroupUser
-from baserow.core.exceptions import UserNotIngroupError
+from baserow.core.models import Group, GroupUser, Application
+from baserow.core.exceptions import UserNotIngroupError, ApplicationTypeDoesNotExist
+from baserow.contrib.database.models import Database
 
 
 @pytest.mark.django_db
@@ -42,6 +43,9 @@ def test_update_group(data_fixture):
     with pytest.raises(UserNotIngroupError):
         handler.update_group(user=user_2, group=group, name='New name')
 
+    with pytest.raises(ValueError):
+        handler.update_group(user=user_2, group=object(), name='New name')
+
 
 @pytest.mark.django_db
 def test_delete_group(data_fixture):
@@ -66,6 +70,9 @@ def test_delete_group(data_fixture):
     assert Group.objects.all().count() == 1
     assert GroupUser.objects.all().count() == 1
 
+    with pytest.raises(ValueError):
+        handler.delete_group(user=user_2, group=object())
+
 
 @pytest.mark.django_db
 def test_order_groups(data_fixture):
@@ -92,3 +99,69 @@ def test_order_groups(data_fixture):
     ug_3.refresh_from_db()
 
     assert [1, 2, 3] == [ug_2.order, ug_1.order, ug_3.order]
+
+
+@pytest.mark.django_db
+def test_create_database_application(data_fixture):
+    user = data_fixture.create_user()
+    user_2 = data_fixture.create_user()
+    group = data_fixture.create_group(user=user)
+
+    handler = CoreHandler()
+    handler.create_application(user=user, group=group, type='database',
+                               name='Test database')
+
+    assert Application.objects.all().count() == 1
+    assert Database.objects.all().count() == 1
+
+    database = Database.objects.all().first()
+    assert database.name == 'Test database'
+    assert database.order == 1
+    assert database.group == group
+
+    with pytest.raises(UserNotIngroupError):
+        handler.create_application(user=user_2, group=group, type='database', name='')
+
+    with pytest.raises(ApplicationTypeDoesNotExist):
+        handler.create_application(user=user, group=group, type='UNKNOWN', name='')
+
+
+@pytest.mark.django_db
+def test_update_database_application(data_fixture):
+    user = data_fixture.create_user()
+    user_2 = data_fixture.create_user()
+    group = data_fixture.create_group(user=user)
+    database = data_fixture.create_database_application(group=group)
+
+    handler = CoreHandler()
+
+    with pytest.raises(UserNotIngroupError):
+        handler.update_application(user=user_2, application=database, name='Test 1')
+
+    with pytest.raises(ValueError):
+        handler.update_application(user=user_2, application=object(), name='Test 1')
+
+    handler.update_application(user=user, application=database, name='Test 1')
+
+    database.refresh_from_db()
+
+    assert database.name == 'Test 1'
+
+@pytest.mark.django_db
+def test_delete_database_application(data_fixture):
+    user = data_fixture.create_user()
+    user_2 = data_fixture.create_user()
+    group = data_fixture.create_group(user=user)
+    database = data_fixture.create_database_application(group=group)
+
+    handler = CoreHandler()
+
+    with pytest.raises(UserNotIngroupError):
+        handler.delete_application(user=user_2, application=database)
+
+    with pytest.raises(ValueError):
+        handler.delete_application(user=user_2, application=object())
+
+    assert Database.objects.all().count() == 1
+    handler.delete_application(user=user, application=database)
+    assert Database.objects.all().count() == 0

backend/tests/baserow/core/test_core_utils.py

@@ -0,0 +1,30 @@
+from baserow.core.utils import extract_allowed, set_allowed_attrs
+
+
+def test_extract_allowed():
+    assert extract_allowed({
+        'test_1': 'test_1',
+        'test_2': 'test_2'
+    }, ['test_1']) == {
+        'test_1': 'test_1'
+    }
+
+    assert extract_allowed({}, ['test_1']) == {}
+    assert extract_allowed({'test_1': 'test'}, ['test_2']) == {}
+    assert extract_allowed({'test_1': 'test'}, []) == {}
+
+
+def test_set_allowed_attrs():
+    class Tmp(object):
+        test_1 = None
+        test_2 = None
+
+    tmp1 = Tmp()
+    tmp1 = set_allowed_attrs(
+        {'test_1': 'test', 'test_2': 'test'},
+        ['test_1'],
+        tmp1
+    )
+
+    assert tmp1.test_1 == 'test'
+    assert tmp1.test_2 is None

backend/tests/fixtures/__init__.py

@@ -2,7 +2,8 @@ from faker import Faker
 
 from .user import UserFixtures
 from .group import GroupFixtures
+from .application import ApplicationFixtures
 
 
-class Fixtures(UserFixtures, GroupFixtures):
+class Fixtures(UserFixtures, GroupFixtures, ApplicationFixtures):
     fake = Faker()

backend/tests/fixtures/application.py

@@ -0,0 +1,15 @@
+from baserow.contrib.database.models import Database
+
+
+class ApplicationFixtures:
+    def create_database_application(self, **kwargs):
+        if 'group' not in kwargs:
+            kwargs['group'] = self.create_group()
+
+        if 'name' not in kwargs:
+            kwargs['name'] = self.fake.name()
+
+        if 'order' not in kwargs:
+            kwargs['order'] = 0
+
+        return Database.objects.create(**kwargs)