From a271d71aa618f06a8266c55b8e63aeea35a50baf Mon Sep 17 00:00:00 2001 From: Nicolas <32845761+nicoklaus@users.noreply.github.com> Date: Wed, 13 May 2026 12:22:45 +0000 Subject: [PATCH 01/10] feat: add support for django LDAPSearchUnion Signed-off-by: Nicolas <32845761+nicoklaus@users.noreply.github.com> --- dejacode/settings.py | 67 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 66 insertions(+), 1 deletion(-) diff --git a/dejacode/settings.py b/dejacode/settings.py index eb1040cf..d5c246d9 100644 --- a/dejacode/settings.py +++ b/dejacode/settings.py @@ -767,7 +767,72 @@ def get_fake_redis_connection(config, use_strict_redis): # AUTH_LDAP_USER_FILTERSTR="(uid=%(user)s)" AUTH_LDAP_USER_FILTERSTR = env.str("AUTH_LDAP_USER_FILTERSTR", default="") -AUTH_LDAP_USER_SEARCH = LDAPSearch(AUTH_LDAP_USER_DN, ldap.SCOPE_SUBTREE, AUTH_LDAP_USER_FILTERSTR) +# Optional: Define multiple LDAP user searches using a JSON list. +# When provided, this setting overrides AUTH_LDAP_USER_DN and AUTH_LDAP_USER_FILTERSTR. +# +# Example: +# AUTH_LDAP_USER_SEARCHES = """ +# [ +# { +# "base": "ou=users,dc=example,dc=com", +# "filter": "(uid=%(user)s)" +# }, +# { +# "base": "ou=otherusers,dc=example,dc=com", +# "filter": "(uid=%(user)s)" +# } +# ] +# """ +# +# Hint: use as a single line string within docker env +# +# Each entry must define: +# - "base": The base DN to search +# - "filter": The LDAP filter (must include %(user)s) +# +# All searches are combined using LDAPSearchUnion. +AUTH_LDAP_USER_SEARCHES = env.str("AUTH_LDAP_USER_SEARCHES", default="") + +if AUTH_LDAP_USER_SEARCHES: + import json + from django_auth_ldap.config import LDAPSearchUnion + + try: + ldap_search_definitions = json.loads(AUTH_LDAP_USER_SEARCHES) + except json.JSONDecodeError as e: + raise ValueError("Invalid JSON in AUTH_LDAP_USER_SEARCHES") from e + + if not isinstance(ldap_search_definitions, list): + raise ValueError("AUTH_LDAP_USER_SEARCHES must be a JSON list") + + ldap_searches = [] + for search_definition in ldap_search_definitions: + if not isinstance(search_definition, dict): + raise ValueError("Each entry must be an object") + + base_dn = search_definition.get("base") + filterstr = search_definition.get("filter") + + if not base_dn or not filterstr: + raise ValueError("Each LDAP search entry must define 'base' and 'filter'") + + ldap_searches.append( + LDAPSearch(base_dn, ldap.SCOPE_SUBTREE, filterstr) + ) + + if not ldap_searches: + raise ValueError("AUTH_LDAP_USER_SEARCHES cannot be empty") + + # Always use LDAPSearchUnion, even for a single search entry. + AUTH_LDAP_USER_SEARCH = LDAPSearchUnion(*ldap_searches) + +else: + # Fallback to single LDAP search configuration. + AUTH_LDAP_USER_SEARCH = LDAPSearch( + AUTH_LDAP_USER_DN, + ldap.SCOPE_SUBTREE, + AUTH_LDAP_USER_FILTERSTR, + ) # When AUTH_LDAP_AUTOCREATE_USER is True (default), a new DejaCode user will be # created in the database with the minimum permission (a read-only user). From 498db9184f87527a2b2c7307f7516e79f14f0680 Mon Sep 17 00:00:00 2001 From: Nicolas <32845761+nicoklaus@users.noreply.github.com> Date: Wed, 13 May 2026 12:23:01 +0000 Subject: [PATCH 02/10] doc: add documentation for USER_SEARCHES Signed-off-by: Nicolas <32845761+nicoklaus@users.noreply.github.com> --- docs/application-settings.rst | 36 +++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/docs/application-settings.rst b/docs/application-settings.rst index d7e1903f..9a55b36e 100644 --- a/docs/application-settings.rst +++ b/docs/application-settings.rst @@ -383,6 +383,42 @@ It must return exactly one result for authentication to succeed. AUTH_LDAP_USER_DN="ou=users,dc=example,dc=com" AUTH_LDAP_USER_FILTERSTR="(uid=%(user)s)" +USER_SEARCHES +------------- + +To search across multiple LDAP locations, use +``AUTH_LDAP_USER_SEARCHES``. + +When this setting is provided, it overrides both +``AUTH_LDAP_USER_DN`` and ``AUTH_LDAP_USER_FILTERSTR``. + +The setting must contain a JSON list of search definitions. Each entry +must define: + +- ``base``: The base DN to search +- ``filter``: The LDAP filter (must include ``%(user)s``) + +All configured searches are combined using ``LDAPSearchUnion``. + +Example: + +.. code-block:: python + + AUTH_LDAP_USER_SEARCHES = """ + [ + { + "base": "ou=users,dc=example,dc=com", + "filter": "(uid=%(user)s)" + }, + { + "base": "ou=otherusers,dc=example,dc=com", + "filter": "(uid=%(user)s)" + } + ] + """ + +For usage in a ``docker.env`` file only a single line string is accepted. + AUTOCREATE_USER --------------- From 1410e991be01f5235646d82aacc64671cac19a9a Mon Sep 17 00:00:00 2001 From: Nicolas <32845761+nicoklaus@users.noreply.github.com> Date: Wed, 1 Jul 2026 16:38:37 +0200 Subject: [PATCH 03/10] doc: rename USER_SEARCHES to AUTH_LDAP_USER_SEARCHES Signed-off-by: Nicolas <32845761+nicoklaus@users.noreply.github.com> --- docs/application-settings.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/application-settings.rst b/docs/application-settings.rst index 9a55b36e..943c9dfe 100644 --- a/docs/application-settings.rst +++ b/docs/application-settings.rst @@ -383,8 +383,8 @@ It must return exactly one result for authentication to succeed. AUTH_LDAP_USER_DN="ou=users,dc=example,dc=com" AUTH_LDAP_USER_FILTERSTR="(uid=%(user)s)" -USER_SEARCHES -------------- +AUTH_LDAP_USER_SEARCHES +----------------------- To search across multiple LDAP locations, use ``AUTH_LDAP_USER_SEARCHES``. From ef9ff07c1e3e5c5471922e889353830c7529fe4c Mon Sep 17 00:00:00 2001 From: Nicolas <32845761+nicoklaus@users.noreply.github.com> Date: Wed, 1 Jul 2026 16:40:21 +0200 Subject: [PATCH 04/10] feat: extract ldap search parsing and validation to dejacode_toolkit/ldap.py Signed-off-by: Nicolas <32845761+nicoklaus@users.noreply.github.com> --- dejacode/settings.py | 48 +++++---------------------------- dejacode_toolkit/ldap.py | 57 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+), 41 deletions(-) create mode 100644 dejacode_toolkit/ldap.py diff --git a/dejacode/settings.py b/dejacode/settings.py index d5c246d9..9f4ccde1 100644 --- a/dejacode/settings.py +++ b/dejacode/settings.py @@ -17,6 +17,7 @@ import ldap from django_auth_ldap.config import GroupOfNamesType from django_auth_ldap.config import LDAPSearch +from dejacode_toolkit.ldap import build_user_search # The home directory of the dejacode user that owns the installation. PROJECT_DIR = environ.Path(__file__) - 1 @@ -769,7 +770,7 @@ def get_fake_redis_connection(config, use_strict_redis): # Optional: Define multiple LDAP user searches using a JSON list. # When provided, this setting overrides AUTH_LDAP_USER_DN and AUTH_LDAP_USER_FILTERSTR. -# +# # Example: # AUTH_LDAP_USER_SEARCHES = """ # [ @@ -793,46 +794,11 @@ def get_fake_redis_connection(config, use_strict_redis): # All searches are combined using LDAPSearchUnion. AUTH_LDAP_USER_SEARCHES = env.str("AUTH_LDAP_USER_SEARCHES", default="") -if AUTH_LDAP_USER_SEARCHES: - import json - from django_auth_ldap.config import LDAPSearchUnion - - try: - ldap_search_definitions = json.loads(AUTH_LDAP_USER_SEARCHES) - except json.JSONDecodeError as e: - raise ValueError("Invalid JSON in AUTH_LDAP_USER_SEARCHES") from e - - if not isinstance(ldap_search_definitions, list): - raise ValueError("AUTH_LDAP_USER_SEARCHES must be a JSON list") - - ldap_searches = [] - for search_definition in ldap_search_definitions: - if not isinstance(search_definition, dict): - raise ValueError("Each entry must be an object") - - base_dn = search_definition.get("base") - filterstr = search_definition.get("filter") - - if not base_dn or not filterstr: - raise ValueError("Each LDAP search entry must define 'base' and 'filter'") - - ldap_searches.append( - LDAPSearch(base_dn, ldap.SCOPE_SUBTREE, filterstr) - ) - - if not ldap_searches: - raise ValueError("AUTH_LDAP_USER_SEARCHES cannot be empty") - - # Always use LDAPSearchUnion, even for a single search entry. - AUTH_LDAP_USER_SEARCH = LDAPSearchUnion(*ldap_searches) - -else: - # Fallback to single LDAP search configuration. - AUTH_LDAP_USER_SEARCH = LDAPSearch( - AUTH_LDAP_USER_DN, - ldap.SCOPE_SUBTREE, - AUTH_LDAP_USER_FILTERSTR, - ) +AUTH_LDAP_USER_SEARCH = build_user_search( + AUTH_LDAP_USER_SEARCHES, + AUTH_LDAP_USER_DN, + AUTH_LDAP_USER_FILTERSTR, +) # When AUTH_LDAP_AUTOCREATE_USER is True (default), a new DejaCode user will be # created in the database with the minimum permission (a read-only user). diff --git a/dejacode_toolkit/ldap.py b/dejacode_toolkit/ldap.py new file mode 100644 index 00000000..86e9f2a1 --- /dev/null +++ b/dejacode_toolkit/ldap.py @@ -0,0 +1,57 @@ +# +# Copyright (c) nexB Inc. and others. All rights reserved. +# DejaCode is a trademark of nexB Inc. +# SPDX-License-Identifier: AGPL-3.0-only +# See https://github.com/aboutcode-org/dejacode for support or download. +# See https://aboutcode.org for more information about AboutCode FOSS projects. +# + +import json + +import ldap +from django.core.exceptions import ImproperlyConfigured +from django_auth_ldap.config import LDAPSearch +from django_auth_ldap.config import LDAPSearchUnion + + +def build_user_search(user_searches, user_dn, user_filterstr): + """Return the ``AUTH_LDAP_USER_SEARCH`` object. + + When ``user_searches`` (a raw JSON string) is provided, parse and validate + it and return an ``LDAPSearchUnion``. Otherwise, fall back to a single + ``LDAPSearch`` built from ``user_dn`` and ``user_filterstr``. + """ + if not user_searches: + return LDAPSearch(user_dn, ldap.SCOPE_SUBTREE, user_filterstr) + + try: + definitions = json.loads(user_searches) + except json.JSONDecodeError as e: + raise ImproperlyConfigured( + f"Invalid JSON in AUTH_LDAP_USER_SEARCHES: {e}" + ) from e + + if not isinstance(definitions, list): + raise ImproperlyConfigured("AUTH_LDAP_USER_SEARCHES must be a JSON list") + + if not definitions: + raise ImproperlyConfigured("AUTH_LDAP_USER_SEARCHES cannot be empty") + + searches = [] + for index, entry in enumerate(definitions): + if not isinstance(entry, dict): + raise ImproperlyConfigured( + f"AUTH_LDAP_USER_SEARCHES[{index}] must be a JSON object" + ) + + base_dn = entry.get("base") + filterstr = entry.get("filter") + + if not base_dn or not filterstr: + raise ImproperlyConfigured( + f"AUTH_LDAP_USER_SEARCHES[{index}] must define 'base' and 'filter'" + ) + + searches.append(LDAPSearch(base_dn, ldap.SCOPE_SUBTREE, filterstr)) + + return LDAPSearchUnion(*searches) From 79f5016b383f2bcab9c89a61a6e124abffe721cb Mon Sep 17 00:00:00 2001 From: Nicolas <32845761+nicoklaus@users.noreply.github.com> Date: Wed, 1 Jul 2026 16:42:28 +0200 Subject: [PATCH 05/10] feat: add unit test for LDAPSearch Signed-off-by: Nicolas <32845761+nicoklaus@users.noreply.github.com> --- dje/tests/test_ldap_config.py | 74 +++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 dje/tests/test_ldap_config.py diff --git a/dje/tests/test_ldap_config.py b/dje/tests/test_ldap_config.py new file mode 100644 index 00000000..0a47b29c --- /dev/null +++ b/dje/tests/test_ldap_config.py @@ -0,0 +1,74 @@ +# +# Copyright (c) nexB Inc. and others. All rights reserved. +# DejaCode is a trademark of nexB Inc. +# SPDX-License-Identifier: AGPL-3.0-only +# See https://github.com/aboutcode-org/dejacode for support or download. +# See https://aboutcode.org for more information about AboutCode FOSS projects. +# + +from django.core.exceptions import ImproperlyConfigured +from django.test import SimpleTestCase + +from django_auth_ldap.config import LDAPSearch +from django_auth_ldap.config import LDAPSearchUnion + +from dejacode.ldap_config import build_user_search + + +class BuildUserSearchTestCase(SimpleTestCase): + def test_build_user_search_fallback_to_single_search_when_empty(self): + result = build_user_search("", "ou=users,dc=example,dc=com", "(uid=%(user)s)") + self.assertIsInstance(result, LDAPSearch) + + def test_build_user_search_valid_json_returns_union(self): + raw = ( + '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"},' + ' {"base": "ou=b,dc=example,dc=com", "filter": "(uid=%(user)s)"}]' + ) + result = build_user_search(raw, "", "") + self.assertIsInstance(result, LDAPSearchUnion) + + def test_build_user_search_single_entry_still_returns_union(self): + raw = '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"}]' + result = build_user_search(raw, "", "") + self.assertIsInstance(result, LDAPSearchUnion) + + def test_build_user_search_invalid_json_raises(self): + with self.assertRaisesMessage(ImproperlyConfigured, "Invalid JSON"): + build_user_search("{not json", "", "") + + def test_build_user_search_not_a_list_raises(self): + with self.assertRaisesMessage(ImproperlyConfigured, "must be a JSON list"): + build_user_search('{"base": "x", "filter": "y"}', "", "") + + def test_build_user_search_empty_list_raises(self): + with self.assertRaisesMessage(ImproperlyConfigured, "cannot be empty"): + build_user_search("[]", "", "") + + def test_build_user_search_entry_not_object_raises(self): + with self.assertRaisesMessage(ImproperlyConfigured, "[0] must be a JSON object"): + build_user_search('["not an object"]', "", "") + + def test_build_user_search_missing_base_raises(self): + raw = '[{"filter": "(uid=%(user)s)"}]' + with self.assertRaisesMessage( + ImproperlyConfigured, "[0] must define 'base' and 'filter'" + ): + build_user_search(raw, "", "") + + def test_build_user_search_missing_filter_raises(self): + raw = '[{"base": "ou=a,dc=example,dc=com"}]' + with self.assertRaisesMessage( + ImproperlyConfigured, "[0] must define 'base' and 'filter'" + ): + build_user_search(raw, "", "") + + def test_build_user_search_error_index_points_to_bad_entry(self): + raw = ( + '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"},' + ' {"base": "ou=b,dc=example,dc=com"}]' + ) + with self.assertRaisesMessage( + ImproperlyConfigured, "[1] must define 'base' and 'filter'" + ): + build_user_search(raw, "", "") From 6e5426e8040e2c3bd5323841959d2435ea4efce8 Mon Sep 17 00:00:00 2001 From: Nicolas <32845761+nicoklaus@users.noreply.github.com> Date: Wed, 1 Jul 2026 16:50:13 +0200 Subject: [PATCH 06/10] fix: linting issues Signed-off-by: Nicolas <32845761+nicoklaus@users.noreply.github.com> --- dejacode/settings.py | 1 + dejacode_toolkit/ldap.py | 14 ++++++-------- dje/tests/test_ldap_config.py | 14 ++++---------- 3 files changed, 11 insertions(+), 18 deletions(-) diff --git a/dejacode/settings.py b/dejacode/settings.py index e4d8a832..e210bd42 100644 --- a/dejacode/settings.py +++ b/dejacode/settings.py @@ -17,6 +17,7 @@ import ldap from django_auth_ldap.config import GroupOfNamesType from django_auth_ldap.config import LDAPSearch + from dejacode_toolkit.ldap import build_user_search # The home directory of the dejacode user that owns the installation. diff --git a/dejacode_toolkit/ldap.py b/dejacode_toolkit/ldap.py index 86e9f2a1..5fc2d7f3 100644 --- a/dejacode_toolkit/ldap.py +++ b/dejacode_toolkit/ldap.py @@ -8,14 +8,16 @@ import json -import ldap from django.core.exceptions import ImproperlyConfigured + +import ldap from django_auth_ldap.config import LDAPSearch from django_auth_ldap.config import LDAPSearchUnion def build_user_search(user_searches, user_dn, user_filterstr): - """Return the ``AUTH_LDAP_USER_SEARCH`` object. + """ + Return the ``AUTH_LDAP_USER_SEARCH`` object. When ``user_searches`` (a raw JSON string) is provided, parse and validate it and return an ``LDAPSearchUnion``. Otherwise, fall back to a single @@ -27,9 +29,7 @@ def build_user_search(user_searches, user_dn, user_filterstr): try: definitions = json.loads(user_searches) except json.JSONDecodeError as e: - raise ImproperlyConfigured( - f"Invalid JSON in AUTH_LDAP_USER_SEARCHES: {e}" - ) from e + raise ImproperlyConfigured(f"Invalid JSON in AUTH_LDAP_USER_SEARCHES: {e}") from e if not isinstance(definitions, list): raise ImproperlyConfigured("AUTH_LDAP_USER_SEARCHES must be a JSON list") @@ -40,9 +40,7 @@ def build_user_search(user_searches, user_dn, user_filterstr): searches = [] for index, entry in enumerate(definitions): if not isinstance(entry, dict): - raise ImproperlyConfigured( - f"AUTH_LDAP_USER_SEARCHES[{index}] must be a JSON object" - ) + raise ImproperlyConfigured(f"AUTH_LDAP_USER_SEARCHES[{index}] must be a JSON object") base_dn = entry.get("base") filterstr = entry.get("filter") diff --git a/dje/tests/test_ldap_config.py b/dje/tests/test_ldap_config.py index 0a47b29c..a54500ec 100644 --- a/dje/tests/test_ldap_config.py +++ b/dje/tests/test_ldap_config.py @@ -12,7 +12,7 @@ from django_auth_ldap.config import LDAPSearch from django_auth_ldap.config import LDAPSearchUnion -from dejacode.ldap_config import build_user_search +from dejacode_toolkit.ldap import build_user_search class BuildUserSearchTestCase(SimpleTestCase): @@ -51,16 +51,12 @@ def test_build_user_search_entry_not_object_raises(self): def test_build_user_search_missing_base_raises(self): raw = '[{"filter": "(uid=%(user)s)"}]' - with self.assertRaisesMessage( - ImproperlyConfigured, "[0] must define 'base' and 'filter'" - ): + with self.assertRaisesMessage(ImproperlyConfigured, "[0] must define 'base' and 'filter'"): build_user_search(raw, "", "") def test_build_user_search_missing_filter_raises(self): raw = '[{"base": "ou=a,dc=example,dc=com"}]' - with self.assertRaisesMessage( - ImproperlyConfigured, "[0] must define 'base' and 'filter'" - ): + with self.assertRaisesMessage(ImproperlyConfigured, "[0] must define 'base' and 'filter'"): build_user_search(raw, "", "") def test_build_user_search_error_index_points_to_bad_entry(self): @@ -68,7 +64,5 @@ def test_build_user_search_error_index_points_to_bad_entry(self): '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"},' ' {"base": "ou=b,dc=example,dc=com"}]' ) - with self.assertRaisesMessage( - ImproperlyConfigured, "[1] must define 'base' and 'filter'" - ): + with self.assertRaisesMessage(ImproperlyConfigured, "[1] must define 'base' and 'filter'"): build_user_search(raw, "", "") From 460dd8b9fe4b02c8fcb8d69997f34f2edb8544fa Mon Sep 17 00:00:00 2001 From: tdruez Date: Tue, 6 Oct 2026 11:46:34 +0400 Subject: [PATCH 07/10] fix: move LDAP search builder out of dejacode_toolkit and validate filter placeholder Signed-off-by: tdruez --- .../ldap.py => dejacode/ldap_config.py | 9 +++- dejacode/settings.py | 30 ++---------- dje/tests/test_ldap_config.py | 48 ++++++++++++------- docs/application-settings.rst | 17 +------ 4 files changed, 46 insertions(+), 58 deletions(-) rename dejacode_toolkit/ldap.py => dejacode/ldap_config.py (87%) diff --git a/dejacode_toolkit/ldap.py b/dejacode/ldap_config.py similarity index 87% rename from dejacode_toolkit/ldap.py rename to dejacode/ldap_config.py index 5fc2d7f3..2bc1ce1b 100644 --- a/dejacode_toolkit/ldap.py +++ b/dejacode/ldap_config.py @@ -28,8 +28,8 @@ def build_user_search(user_searches, user_dn, user_filterstr): try: definitions = json.loads(user_searches) - except json.JSONDecodeError as e: - raise ImproperlyConfigured(f"Invalid JSON in AUTH_LDAP_USER_SEARCHES: {e}") from e + except json.JSONDecodeError as error: + raise ImproperlyConfigured(f"Invalid JSON in AUTH_LDAP_USER_SEARCHES: {error}") from error if not isinstance(definitions, list): raise ImproperlyConfigured("AUTH_LDAP_USER_SEARCHES must be a JSON list") @@ -50,6 +50,11 @@ def build_user_search(user_searches, user_dn, user_filterstr): f"AUTH_LDAP_USER_SEARCHES[{index}] must define 'base' and 'filter'" ) + if "%(user)s" not in filterstr: + raise ImproperlyConfigured( + f"AUTH_LDAP_USER_SEARCHES[{index}] 'filter' must include the %(user)s placeholder" + ) + searches.append(LDAPSearch(base_dn, ldap.SCOPE_SUBTREE, filterstr)) return LDAPSearchUnion(*searches) diff --git a/dejacode/settings.py b/dejacode/settings.py index e210bd42..f26c507c 100644 --- a/dejacode/settings.py +++ b/dejacode/settings.py @@ -18,7 +18,7 @@ from django_auth_ldap.config import GroupOfNamesType from django_auth_ldap.config import LDAPSearch -from dejacode_toolkit.ldap import build_user_search +from dejacode.ldap_config import build_user_search # The home directory of the dejacode user that owns the installation. PROJECT_DIR = environ.Path(__file__) - 1 @@ -777,30 +777,10 @@ def get_fake_redis_connection(config, use_strict_redis): # AUTH_LDAP_USER_FILTERSTR="(uid=%(user)s)" AUTH_LDAP_USER_FILTERSTR = env.str("AUTH_LDAP_USER_FILTERSTR", default="") -# Optional: Define multiple LDAP user searches using a JSON list. -# When provided, this setting overrides AUTH_LDAP_USER_DN and AUTH_LDAP_USER_FILTERSTR. -# -# Example: -# AUTH_LDAP_USER_SEARCHES = """ -# [ -# { -# "base": "ou=users,dc=example,dc=com", -# "filter": "(uid=%(user)s)" -# }, -# { -# "base": "ou=otherusers,dc=example,dc=com", -# "filter": "(uid=%(user)s)" -# } -# ] -# """ -# -# Hint: use as a single line string within docker env -# -# Each entry must define: -# - "base": The base DN to search -# - "filter": The LDAP filter (must include %(user)s) -# -# All searches are combined using LDAPSearchUnion. +# Optional: JSON list of user searches, combined using LDAPSearchUnion. +# Each entry defines a "base" DN and a "filter" including the %(user)s placeholder. +# When provided, AUTH_LDAP_USER_DN and AUTH_LDAP_USER_FILTERSTR are ignored. +# AUTH_LDAP_USER_SEARCHES=[{"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"}] AUTH_LDAP_USER_SEARCHES = env.str("AUTH_LDAP_USER_SEARCHES", default="") AUTH_LDAP_USER_SEARCH = build_user_search( diff --git a/dje/tests/test_ldap_config.py b/dje/tests/test_ldap_config.py index a54500ec..5d077078 100644 --- a/dje/tests/test_ldap_config.py +++ b/dje/tests/test_ldap_config.py @@ -12,26 +12,36 @@ from django_auth_ldap.config import LDAPSearch from django_auth_ldap.config import LDAPSearchUnion -from dejacode_toolkit.ldap import build_user_search +from dejacode.ldap_config import build_user_search class BuildUserSearchTestCase(SimpleTestCase): def test_build_user_search_fallback_to_single_search_when_empty(self): - result = build_user_search("", "ou=users,dc=example,dc=com", "(uid=%(user)s)") - self.assertIsInstance(result, LDAPSearch) + user_search = build_user_search("", "ou=users,dc=example,dc=com", "(uid=%(user)s)") + self.assertIsInstance(user_search, LDAPSearch) + self.assertEqual("ou=users,dc=example,dc=com", user_search.base_dn) + self.assertEqual("(uid=%(user)s)", user_search.filterstr) def test_build_user_search_valid_json_returns_union(self): - raw = ( + user_searches = ( '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"},' - ' {"base": "ou=b,dc=example,dc=com", "filter": "(uid=%(user)s)"}]' + ' {"base": "ou=b,dc=example,dc=com", "filter": "(cn=%(user)s)"}]' ) - result = build_user_search(raw, "", "") - self.assertIsInstance(result, LDAPSearchUnion) + user_search = build_user_search(user_searches, "", "") + self.assertIsInstance(user_search, LDAPSearchUnion) + search_values = [(search.base_dn, search.filterstr) for search in user_search.searches] + expected = [ + ("ou=a,dc=example,dc=com", "(uid=%(user)s)"), + ("ou=b,dc=example,dc=com", "(cn=%(user)s)"), + ] + self.assertEqual(expected, search_values) def test_build_user_search_single_entry_still_returns_union(self): - raw = '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"}]' - result = build_user_search(raw, "", "") - self.assertIsInstance(result, LDAPSearchUnion) + user_searches = '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"}]' + user_search = build_user_search(user_searches, "", "") + self.assertIsInstance(user_search, LDAPSearchUnion) + search_values = [(search.base_dn, search.filterstr) for search in user_search.searches] + self.assertEqual([("ou=a,dc=example,dc=com", "(uid=%(user)s)")], search_values) def test_build_user_search_invalid_json_raises(self): with self.assertRaisesMessage(ImproperlyConfigured, "Invalid JSON"): @@ -50,19 +60,25 @@ def test_build_user_search_entry_not_object_raises(self): build_user_search('["not an object"]', "", "") def test_build_user_search_missing_base_raises(self): - raw = '[{"filter": "(uid=%(user)s)"}]' + user_searches = '[{"filter": "(uid=%(user)s)"}]' with self.assertRaisesMessage(ImproperlyConfigured, "[0] must define 'base' and 'filter'"): - build_user_search(raw, "", "") + build_user_search(user_searches, "", "") def test_build_user_search_missing_filter_raises(self): - raw = '[{"base": "ou=a,dc=example,dc=com"}]' + user_searches = '[{"base": "ou=a,dc=example,dc=com"}]' with self.assertRaisesMessage(ImproperlyConfigured, "[0] must define 'base' and 'filter'"): - build_user_search(raw, "", "") + build_user_search(user_searches, "", "") + + def test_build_user_search_filter_without_user_placeholder_raises(self): + user_searches = '[{"base": "ou=a,dc=example,dc=com", "filter": "(objectClass=person)"}]' + expected_message = "[0] 'filter' must include the %(user)s placeholder" + with self.assertRaisesMessage(ImproperlyConfigured, expected_message): + build_user_search(user_searches, "", "") def test_build_user_search_error_index_points_to_bad_entry(self): - raw = ( + user_searches = ( '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"},' ' {"base": "ou=b,dc=example,dc=com"}]' ) with self.assertRaisesMessage(ImproperlyConfigured, "[1] must define 'base' and 'filter'"): - build_user_search(raw, "", "") + build_user_search(user_searches, "", "") diff --git a/docs/application-settings.rst b/docs/application-settings.rst index 943c9dfe..033c8bbe 100644 --- a/docs/application-settings.rst +++ b/docs/application-settings.rst @@ -400,24 +400,11 @@ must define: All configured searches are combined using ``LDAPSearchUnion``. -Example: +Example, as a single line: .. code-block:: python - AUTH_LDAP_USER_SEARCHES = """ - [ - { - "base": "ou=users,dc=example,dc=com", - "filter": "(uid=%(user)s)" - }, - { - "base": "ou=otherusers,dc=example,dc=com", - "filter": "(uid=%(user)s)" - } - ] - """ - -For usage in a ``docker.env`` file only a single line string is accepted. + AUTH_LDAP_USER_SEARCHES=[{"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"}, {"base": "ou=otherusers,dc=example,dc=com", "filter": "(uid=%(user)s)"}] AUTOCREATE_USER --------------- From fd44e8d5a59449440310d76761c8a8d5141669d9 Mon Sep 17 00:00:00 2001 From: tdruez Date: Tue, 6 Oct 2026 11:57:03 +0400 Subject: [PATCH 08/10] refactor: split LDAP user search union builder and keep default search untouched Signed-off-by: tdruez --- dejacode/ldap_config.py | 60 ++++++++---------- dejacode/settings.py | 12 ++-- dje/tests/test_ldap_config.py | 115 ++++++++++++++++++---------------- 3 files changed, 93 insertions(+), 94 deletions(-) diff --git a/dejacode/ldap_config.py b/dejacode/ldap_config.py index 2bc1ce1b..5793be51 100644 --- a/dejacode/ldap_config.py +++ b/dejacode/ldap_config.py @@ -15,46 +15,40 @@ from django_auth_ldap.config import LDAPSearchUnion -def build_user_search(user_searches, user_dn, user_filterstr): - """ - Return the ``AUTH_LDAP_USER_SEARCH`` object. +def get_user_search(index, search_definition): + """Return an ``LDAPSearch`` from one ``AUTH_LDAP_USER_SEARCHES`` entry.""" + entry_name = f"AUTH_LDAP_USER_SEARCHES[{index}]" - When ``user_searches`` (a raw JSON string) is provided, parse and validate - it and return an ``LDAPSearchUnion``. Otherwise, fall back to a single - ``LDAPSearch`` built from ``user_dn`` and ``user_filterstr``. - """ - if not user_searches: - return LDAPSearch(user_dn, ldap.SCOPE_SUBTREE, user_filterstr) + if not isinstance(search_definition, dict): + raise ImproperlyConfigured(f"{entry_name} must be a JSON object") - try: - definitions = json.loads(user_searches) - except json.JSONDecodeError as error: - raise ImproperlyConfigured(f"Invalid JSON in AUTH_LDAP_USER_SEARCHES: {error}") from error - - if not isinstance(definitions, list): - raise ImproperlyConfigured("AUTH_LDAP_USER_SEARCHES must be a JSON list") + base_dn = search_definition.get("base") + filterstr = search_definition.get("filter") - if not definitions: - raise ImproperlyConfigured("AUTH_LDAP_USER_SEARCHES cannot be empty") + has_base_and_filter = all(isinstance(value, str) and value for value in (base_dn, filterstr)) + if not has_base_and_filter: + raise ImproperlyConfigured( + f"{entry_name} must define 'base' and 'filter' as non-empty strings" + ) - searches = [] - for index, entry in enumerate(definitions): - if not isinstance(entry, dict): - raise ImproperlyConfigured(f"AUTH_LDAP_USER_SEARCHES[{index}] must be a JSON object") + if "%(user)s" not in filterstr: + raise ImproperlyConfigured(f"{entry_name} 'filter' must include the %(user)s placeholder") - base_dn = entry.get("base") - filterstr = entry.get("filter") + return LDAPSearch(base_dn, ldap.SCOPE_SUBTREE, filterstr) - if not base_dn or not filterstr: - raise ImproperlyConfigured( - f"AUTH_LDAP_USER_SEARCHES[{index}] must define 'base' and 'filter'" - ) - if "%(user)s" not in filterstr: - raise ImproperlyConfigured( - f"AUTH_LDAP_USER_SEARCHES[{index}] 'filter' must include the %(user)s placeholder" - ) +def build_user_search_union(user_searches): + """Return an ``LDAPSearchUnion`` from the ``AUTH_LDAP_USER_SEARCHES`` JSON string.""" + try: + search_definitions = json.loads(user_searches) + except json.JSONDecodeError as error: + raise ImproperlyConfigured(f"Invalid JSON in AUTH_LDAP_USER_SEARCHES: {error}") from error - searches.append(LDAPSearch(base_dn, ldap.SCOPE_SUBTREE, filterstr)) + if not isinstance(search_definitions, list) or not search_definitions: + raise ImproperlyConfigured("AUTH_LDAP_USER_SEARCHES must be a non-empty JSON list") + searches = [ + get_user_search(index, search_definition) + for index, search_definition in enumerate(search_definitions) + ] return LDAPSearchUnion(*searches) diff --git a/dejacode/settings.py b/dejacode/settings.py index 7eae3340..6e0b1a80 100644 --- a/dejacode/settings.py +++ b/dejacode/settings.py @@ -18,7 +18,7 @@ from django_auth_ldap.config import GroupOfNamesType from django_auth_ldap.config import LDAPSearch -from dejacode.ldap_config import build_user_search +from dejacode.ldap_config import build_user_search_union # The home directory of the dejacode user that owns the installation. PROJECT_DIR = environ.Path(__file__) - 1 @@ -783,17 +783,15 @@ def get_fake_redis_connection(config, use_strict_redis): # AUTH_LDAP_USER_FILTERSTR="(uid=%(user)s)" AUTH_LDAP_USER_FILTERSTR = env.str("AUTH_LDAP_USER_FILTERSTR", default="") +AUTH_LDAP_USER_SEARCH = LDAPSearch(AUTH_LDAP_USER_DN, ldap.SCOPE_SUBTREE, AUTH_LDAP_USER_FILTERSTR) + # Optional: JSON list of user searches, combined using LDAPSearchUnion. # Each entry defines a "base" DN and a "filter" including the %(user)s placeholder. # When provided, AUTH_LDAP_USER_DN and AUTH_LDAP_USER_FILTERSTR are ignored. # AUTH_LDAP_USER_SEARCHES=[{"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"}] AUTH_LDAP_USER_SEARCHES = env.str("AUTH_LDAP_USER_SEARCHES", default="") - -AUTH_LDAP_USER_SEARCH = build_user_search( - AUTH_LDAP_USER_SEARCHES, - AUTH_LDAP_USER_DN, - AUTH_LDAP_USER_FILTERSTR, -) +if AUTH_LDAP_USER_SEARCHES: + AUTH_LDAP_USER_SEARCH = build_user_search_union(AUTH_LDAP_USER_SEARCHES) # When AUTH_LDAP_AUTOCREATE_USER is True (default), a new DejaCode user will be # created in the database with the minimum permission (a read-only user). diff --git a/dje/tests/test_ldap_config.py b/dje/tests/test_ldap_config.py index 5d077078..ae1dabc5 100644 --- a/dje/tests/test_ldap_config.py +++ b/dje/tests/test_ldap_config.py @@ -9,76 +9,83 @@ from django.core.exceptions import ImproperlyConfigured from django.test import SimpleTestCase +import ldap from django_auth_ldap.config import LDAPSearch from django_auth_ldap.config import LDAPSearchUnion -from dejacode.ldap_config import build_user_search +from dejacode.ldap_config import build_user_search_union +from dejacode.ldap_config import get_user_search -class BuildUserSearchTestCase(SimpleTestCase): - def test_build_user_search_fallback_to_single_search_when_empty(self): - user_search = build_user_search("", "ou=users,dc=example,dc=com", "(uid=%(user)s)") +class LDAPConfigTestCase(SimpleTestCase): + def test_ldap_config_get_user_search(self): + search_definition = {"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"} + user_search = get_user_search(0, search_definition) self.assertIsInstance(user_search, LDAPSearch) self.assertEqual("ou=users,dc=example,dc=com", user_search.base_dn) + self.assertEqual(ldap.SCOPE_SUBTREE, user_search.scope) self.assertEqual("(uid=%(user)s)", user_search.filterstr) - def test_build_user_search_valid_json_returns_union(self): + def test_ldap_config_get_user_search_not_an_object(self): + expected_message = "AUTH_LDAP_USER_SEARCHES[2] must be a JSON object" + with self.assertRaisesMessage(ImproperlyConfigured, expected_message): + get_user_search(2, "ou=users,dc=example,dc=com") + + def test_ldap_config_get_user_search_invalid_base_or_filter(self): + invalid_definitions = [ + {"filter": "(uid=%(user)s)"}, + {"base": "ou=users,dc=example,dc=com"}, + {"base": "", "filter": "(uid=%(user)s)"}, + {"base": ["ou=users,dc=example,dc=com"], "filter": "(uid=%(user)s)"}, + {"base": "ou=users,dc=example,dc=com", "filter": 123}, + ] + expected_message = ( + "AUTH_LDAP_USER_SEARCHES[0] must define 'base' and 'filter' as non-empty strings" + ) + for search_definition in invalid_definitions: + with self.subTest(search_definition=search_definition): + with self.assertRaisesMessage(ImproperlyConfigured, expected_message): + get_user_search(0, search_definition) + + def test_ldap_config_get_user_search_filter_without_user_placeholder(self): + search_definition = {"base": "ou=users,dc=example,dc=com", "filter": "(objectClass=person)"} + expected_message = "[0] 'filter' must include the %(user)s placeholder" + with self.assertRaisesMessage(ImproperlyConfigured, expected_message): + get_user_search(0, search_definition) + + def test_ldap_config_build_user_search_union(self): user_searches = ( - '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"},' - ' {"base": "ou=b,dc=example,dc=com", "filter": "(cn=%(user)s)"}]' + '[{"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"},' + ' {"base": "ou=staff,dc=example,dc=com", "filter": "(cn=%(user)s)"}]' ) - user_search = build_user_search(user_searches, "", "") - self.assertIsInstance(user_search, LDAPSearchUnion) - search_values = [(search.base_dn, search.filterstr) for search in user_search.searches] + user_search_union = build_user_search_union(user_searches) + self.assertIsInstance(user_search_union, LDAPSearchUnion) + search_values = [ + (search.base_dn, search.filterstr) for search in user_search_union.searches + ] expected = [ - ("ou=a,dc=example,dc=com", "(uid=%(user)s)"), - ("ou=b,dc=example,dc=com", "(cn=%(user)s)"), + ("ou=users,dc=example,dc=com", "(uid=%(user)s)"), + ("ou=staff,dc=example,dc=com", "(cn=%(user)s)"), ] self.assertEqual(expected, search_values) - def test_build_user_search_single_entry_still_returns_union(self): - user_searches = '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"}]' - user_search = build_user_search(user_searches, "", "") - self.assertIsInstance(user_search, LDAPSearchUnion) - search_values = [(search.base_dn, search.filterstr) for search in user_search.searches] - self.assertEqual([("ou=a,dc=example,dc=com", "(uid=%(user)s)")], search_values) - - def test_build_user_search_invalid_json_raises(self): - with self.assertRaisesMessage(ImproperlyConfigured, "Invalid JSON"): - build_user_search("{not json", "", "") - - def test_build_user_search_not_a_list_raises(self): - with self.assertRaisesMessage(ImproperlyConfigured, "must be a JSON list"): - build_user_search('{"base": "x", "filter": "y"}', "", "") - - def test_build_user_search_empty_list_raises(self): - with self.assertRaisesMessage(ImproperlyConfigured, "cannot be empty"): - build_user_search("[]", "", "") - - def test_build_user_search_entry_not_object_raises(self): - with self.assertRaisesMessage(ImproperlyConfigured, "[0] must be a JSON object"): - build_user_search('["not an object"]', "", "") - - def test_build_user_search_missing_base_raises(self): - user_searches = '[{"filter": "(uid=%(user)s)"}]' - with self.assertRaisesMessage(ImproperlyConfigured, "[0] must define 'base' and 'filter'"): - build_user_search(user_searches, "", "") - - def test_build_user_search_missing_filter_raises(self): - user_searches = '[{"base": "ou=a,dc=example,dc=com"}]' - with self.assertRaisesMessage(ImproperlyConfigured, "[0] must define 'base' and 'filter'"): - build_user_search(user_searches, "", "") - - def test_build_user_search_filter_without_user_placeholder_raises(self): - user_searches = '[{"base": "ou=a,dc=example,dc=com", "filter": "(objectClass=person)"}]' - expected_message = "[0] 'filter' must include the %(user)s placeholder" + def test_ldap_config_build_user_search_union_invalid_json(self): + expected_message = "Invalid JSON in AUTH_LDAP_USER_SEARCHES" with self.assertRaisesMessage(ImproperlyConfigured, expected_message): - build_user_search(user_searches, "", "") + build_user_search_union("{not json") - def test_build_user_search_error_index_points_to_bad_entry(self): + def test_ldap_config_build_user_search_union_not_a_non_empty_list(self): + expected_message = "AUTH_LDAP_USER_SEARCHES must be a non-empty JSON list" + for user_searches in ["[]", '{"base": "ou=users,dc=example,dc=com"}', '"text"']: + with self.subTest(user_searches=user_searches): + with self.assertRaisesMessage(ImproperlyConfigured, expected_message): + build_user_search_union(user_searches) + + def test_ldap_config_build_user_search_union_invalid_entry_index(self): user_searches = ( - '[{"base": "ou=a,dc=example,dc=com", "filter": "(uid=%(user)s)"},' - ' {"base": "ou=b,dc=example,dc=com"}]' + '[{"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"},' + ' {"base": "ou=staff,dc=example,dc=com"}]' ) - with self.assertRaisesMessage(ImproperlyConfigured, "[1] must define 'base' and 'filter'"): - build_user_search(user_searches, "", "") + expected_message = "AUTH_LDAP_USER_SEARCHES[1] must define 'base' and 'filter'" + with self.assertRaisesMessage(ImproperlyConfigured, expected_message): + build_user_search_union(user_searches) From 56d10495c1cf8b48daae67a50f56074c7e2c92a1 Mon Sep 17 00:00:00 2001 From: tdruez Date: Tue, 6 Oct 2026 12:01:20 +0400 Subject: [PATCH 09/10] docs: clarify the LDAP user searches setting Signed-off-by: tdruez --- dejacode/settings.py | 8 ++++---- docs/application-settings.rst | 29 +++++++++++++++-------------- 2 files changed, 19 insertions(+), 18 deletions(-) diff --git a/dejacode/settings.py b/dejacode/settings.py index 6e0b1a80..fc8abda2 100644 --- a/dejacode/settings.py +++ b/dejacode/settings.py @@ -785,10 +785,10 @@ def get_fake_redis_connection(config, use_strict_redis): AUTH_LDAP_USER_SEARCH = LDAPSearch(AUTH_LDAP_USER_DN, ldap.SCOPE_SUBTREE, AUTH_LDAP_USER_FILTERSTR) -# Optional: JSON list of user searches, combined using LDAPSearchUnion. -# Each entry defines a "base" DN and a "filter" including the %(user)s placeholder. -# When provided, AUTH_LDAP_USER_DN and AUTH_LDAP_USER_FILTERSTR are ignored. -# AUTH_LDAP_USER_SEARCHES=[{"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"}] +# Optional: search users in several locations of the LDAP directory. +# A JSON list with one entry per location: a "base" DN and a "filter" including %(user)s. +# When set, AUTH_LDAP_USER_DN and AUTH_LDAP_USER_FILTERSTR are ignored. +# AUTH_LDAP_USER_SEARCHES=[{"base": "ou=staff,dc=example,dc=com", "filter": "(uid=%(user)s)"}, ...] AUTH_LDAP_USER_SEARCHES = env.str("AUTH_LDAP_USER_SEARCHES", default="") if AUTH_LDAP_USER_SEARCHES: AUTH_LDAP_USER_SEARCH = build_user_search_union(AUTH_LDAP_USER_SEARCHES) diff --git a/docs/application-settings.rst b/docs/application-settings.rst index 033c8bbe..eefe47ba 100644 --- a/docs/application-settings.rst +++ b/docs/application-settings.rst @@ -383,28 +383,29 @@ It must return exactly one result for authentication to succeed. AUTH_LDAP_USER_DN="ou=users,dc=example,dc=com" AUTH_LDAP_USER_FILTERSTR="(uid=%(user)s)" -AUTH_LDAP_USER_SEARCHES ------------------------ +USER_SEARCHES +------------- -To search across multiple LDAP locations, use -``AUTH_LDAP_USER_SEARCHES``. +When users are stored in several locations of the LDAP directory, for example in +different organizational units, use ``AUTH_LDAP_USER_SEARCHES`` instead of +``USER_DN``. -When this setting is provided, it overrides both -``AUTH_LDAP_USER_DN`` and ``AUTH_LDAP_USER_FILTERSTR``. +The value is a JSON list with one entry per location: -The setting must contain a JSON list of search definitions. Each entry -must define: +- ``base``: the distinguished name of the location. +- ``filter``: the filter to find the user, including the ``%(user)s`` placeholder. -- ``base``: The base DN to search -- ``filter``: The LDAP filter (must include ``%(user)s``) +The following example searches users in both ``employees`` and ``contractors``: -All configured searches are combined using ``LDAPSearchUnion``. +.. code-block:: python -Example, as a single line: + AUTH_LDAP_USER_SEARCHES=[{"base": "ou=employees,dc=example,dc=com", "filter": "(uid=%(user)s)"}, {"base": "ou=contractors,dc=example,dc=com", "filter": "(uid=%(user)s)"}] -.. code-block:: python +All locations are searched, and the username must match exactly one user across +them for authentication to succeed. +When set, ``AUTH_LDAP_USER_DN`` and ``AUTH_LDAP_USER_FILTERSTR`` are ignored. - AUTH_LDAP_USER_SEARCHES=[{"base": "ou=users,dc=example,dc=com", "filter": "(uid=%(user)s)"}, {"base": "ou=otherusers,dc=example,dc=com", "filter": "(uid=%(user)s)"}] +.. note:: The value must be written on a single line. AUTOCREATE_USER --------------- From c7a74beaddb5696602441ce8d43e8ae9fe510b52 Mon Sep 17 00:00:00 2001 From: tdruez Date: Tue, 6 Oct 2026 12:10:40 +0400 Subject: [PATCH 10/10] test: authenticate through an LDAP user search union Signed-off-by: tdruez --- dje/tests/test_ldap.py | 13 +++++++++++++ dje/tests/test_ldap_config.py | 4 +++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/dje/tests/test_ldap.py b/dje/tests/test_ldap.py index f0234ec4..ccb00786 100644 --- a/dje/tests/test_ldap.py +++ b/dje/tests/test_ldap.py @@ -43,6 +43,7 @@ from guardian.shortcuts import assign_perm from ldap.ldapobject import SimpleLDAPObject +from dejacode.ldap_config import build_user_search_union from dje.ldap_backend import DejaCodeLDAPBackend from dje.models import Dataspace from dje.models import DataspaceConfiguration @@ -176,6 +177,18 @@ def test_ldap_authentication_populate_user(self): self.assertEqual(user.last_name, "Smith") self.assertEqual(user.email, "bob@test.com") + @override_settings( + AUTH_LDAP_USER_DN_TEMPLATE=None, + AUTH_LDAP_USER_SEARCH=build_user_search_union( + '[{"base": "ou=groups,o=test", "filter": "(uid=%(user)s)"},' + ' {"base": "ou=people,o=test", "filter": "(uid=%(user)s)"}]' + ), + ) + def test_ldap_authentication_user_search_union(self): + user = authenticate(username="bob", password="secret") + self.assertEqual("bob", user.username) + self.assertEqual("bob@test.com", user.email) + def test_ldap_group_active_properly_setup_and_searchable(self): conn = self.ldap_object_class(self.server.ldap_uri) results = conn.search_s("ou=groups,o=test", ldap.SCOPE_ONELEVEL, "(cn=active)") diff --git a/dje/tests/test_ldap_config.py b/dje/tests/test_ldap_config.py index ae1dabc5..a6c80a9f 100644 --- a/dje/tests/test_ldap_config.py +++ b/dje/tests/test_ldap_config.py @@ -49,7 +49,9 @@ def test_ldap_config_get_user_search_invalid_base_or_filter(self): def test_ldap_config_get_user_search_filter_without_user_placeholder(self): search_definition = {"base": "ou=users,dc=example,dc=com", "filter": "(objectClass=person)"} - expected_message = "[0] 'filter' must include the %(user)s placeholder" + expected_message = ( + "AUTH_LDAP_USER_SEARCHES[0] 'filter' must include the %(user)s placeholder" + ) with self.assertRaisesMessage(ImproperlyConfigured, expected_message): get_user_search(0, search_definition)