Add public API tests and logging for test debugging

Author: AlanCoding

ansible_base/rbac/models/content_type.py

@@ -1,4 +1,5 @@
 import inspect
+import logging
 from collections import defaultdict
 from typing import Any, Dict, Optional, Sequence, Tuple, Type, Union
 
@@ -10,6 +11,8 @@
 
 from ..remote import RemoteObject, get_local_resource_prefix, get_resource_prefix
 
+logger = logging.getLogger(__name__)
+
 
 class DABContentTypeManager(django_models.Manager["DABContentType"]):
     """Manager storing DABContentType objects in a local cache like original ContentType.
@@ -73,12 +76,12 @@ def get_for_model(
         try:
             ct = self.get(service=service, app_label=opts.app_label, model=opts.model_name)
         except self.model.DoesNotExist:
+            logger.warning(f'Could not find content type for {(service, opts.app_label, opts.model_name)}, so creating new')
             ct, _ = self.get_or_create(
                 service=service,
                 app_label=opts.app_label,
                 model=opts.model_name,
-                api_slug=f'{service}.{opts.model_name}',
-                pk_field_type=model._meta.pk.db_type(connection),
+                defaults=dict(api_slug=f'{service}.{opts.model_name}', pk_field_type=model._meta.pk.db_type(connection)),
             )
         self._add_to_cache(self.db, ct)
         return ct
@@ -138,6 +141,7 @@ def get_for_models(
                     pk_field_type = opts_models[0]._meta.pk.db_type(connection)
                 else:
                     pk_field_type = 'integer'
+                logger.warning(f'Could not find content type for {(service_create, app_label, model_name)}, so creating new, out of:\n{needed_models.keys()}')
                 ct = self.create(
                     service=service_create, app_label=app_label, model=model_name, api_slug=f'{service_create}.{model_name}', pk_field_type=pk_field_type
                 )

test_app/tests/rbac/remote/conftest.py

@@ -0,0 +1,21 @@
+import pytest
+
+from ansible_base.rbac.models import DABContentType, DABPermission, RoleDefinition
+
+
+@pytest.fixture
+def foo_type():
+    "Idea is that this is a remote type, in this case, the foo type"
+    return DABContentType.objects.create(service='foo', model='foo', app_label='foo')
+
+
+@pytest.fixture
+def foo_permission(foo_type):
+    return DABPermission.objects.create(codename='foo_foo', content_type=foo_type)
+
+
+@pytest.fixture
+def foo_rd(foo_type, foo_permission):
+    return RoleDefinition.objects.create_from_permissions(
+        name='Foo fooers for the foos in foo service', permissions=[foo_permission.api_slug], content_type=foo_type
+    )

test_app/tests/rbac/remote/test_public_api_compat.py

@@ -0,0 +1,33 @@
+import pytest
+from django.test.utils import override_settings
+
+from ansible_base.lib.utils.response import get_relative_url
+from ansible_base.rbac.models import RoleDefinition
+
+
+@pytest.mark.django_db
+def test_role_definition_list_remote_and_local(admin_api_client, inv_rd, foo_rd):
+    url = get_relative_url('roledefinition-list')
+    response = admin_api_client.get(url)
+    assert response.status_code == 200
+    assert response.data['next'] is None  # sanity, will mess up test if there are more pages
+    rd_by_name = {rd['name']: rd for rd in response.data['results']}
+    assert inv_rd.name in rd_by_name
+    assert foo_rd.name in rd_by_name
+    # Assertion coppied from API test test_get_role_definition
+    assert set(rd_by_name[inv_rd.name]['permissions']) == set(['aap.change_inventory', 'aap.view_inventory'])
+    assert rd_by_name[foo_rd.name]['permissions'] == ['foo.foo_foo']
+
+
+@pytest.mark.django_db
+@pytest.mark.skip
+def test_create_remote_role_definition(admin_api_client, foo_type, foo_permission):
+    """
+    Test creation of a custom, remote role definition.
+    """
+    url = get_relative_url("roledefinition-list")
+    data = dict(name='foo-foo-foo-custom', description='bar', permissions=[foo_permission.api_slug], content_type=foo_type.api_slug)
+    response = admin_api_client.post(url, data=data, format="json")
+    assert response.status_code == 201, response.data
+    assert response.data['name'] == 'foo-foo-foo-custom'
+    assert response.data['permissions'] == ['foo.foo_foo']

test_app/tests/rbac/remote/test_remote_models.py renamed to test_app/tests/rbac/remote/test_remote_assignment.py

@@ -5,13 +5,14 @@
 
 
 @pytest.mark.django_db
-def test_give_remote_permission(rando):
-    foo_type = DABContentType.objects.create(service='foo', model='foo', app_label='foo')
-    assert foo_type.service == 'foo'
-    DABPermission.objects.create(codename='foo_foo', content_type=foo_type)
-    rd = RoleDefinition.objects.create_from_permissions(name='Foo fooers for the foos in foo service', permissions=['foo.foo_foo'], content_type=foo_type)
+def test_give_remote_permission(rando, foo_type, foo_permission, foo_rd):
+    assert foo_type.service == 'foo'  # a place, a domain, a server, known as foo
+    assert foo_type.api_slug == 'foo.foo'  # there lives a foo in foo
+
+    assert foo_permission.api_slug == 'foo.foo_foo'  # expression of the ability that one may foo a foo
+
     a_foo = RemoteObject(content_type=foo_type, object_id=42)
-    assignment = rd.give_permission(rando, a_foo)
+    assignment = foo_rd.give_permission(rando, a_foo)
 
     assignment = RoleUserAssignment.objects.get(pk=assignment.pk)
     assert isinstance(assignment.content_object, RemoteObject)