Debian Codegraph @

dirsrvtests/tests/suites/replication/mmr_single_value_conflict_test.py

raw
1 # --- BEGIN COPYRIGHT BLOCK ---
2 # Copyright (C) 2026 Red Hat, Inc.
3 # All rights reserved.
4 #
5 # License: GPL (version 3 or any later version).
6 # See LICENSE for details.
7 # --- END COPYRIGHT BLOCK ---
8 #
9
10
11 import logging
12 import os
13 import time
14
15 import ldap
16 import pytest
17 from test389.topologies import create_topology
18
19 from lib389._constants import DEFAULT_SUFFIX, ReplicaRole
20 from lib389.idm.organizationalunit import OrganizationalUnits
21 from lib389.idm.user import DEFAULT_BASEDN_RDN
22 from lib389.replica import ReplicationManager
23 from lib389.idm.user import UserAccounts
24
25 pytestmark = pytest.mark.tier1
26
27 DEBUGGING = os.getenv("DEBUGGING", default=False)
28 if DEBUGGING:
29 logging.getLogger(__name__).setLevel(logging.DEBUG)
30 else:
31 logging.getLogger(__name__).setLevel(logging.INFO)
32 log = logging.getLogger(__name__)
33
34 MAX_EMPLOYEENUMBER_USER = 20
35 MAX_STANDARD_USER = 100
36 MAX_USER = MAX_STANDARD_USER + MAX_EMPLOYEENUMBER_USER
37 EMPLOYEENUMBER_RDN_START = 0
38
39 USER_UID_PREFIX = "user_"
40 BASE_PEOPLE = f"{DEFAULT_BASEDN_RDN},{DEFAULT_SUFFIX}"
41 BASE_DISTINGUISHED = f"ou=distinguished,{BASE_PEOPLE}"
42 BASE_REGULAR = f"ou=regular,{BASE_PEOPLE}"
43 INITIAL_EMPLOYEE_NUMBER = b"11"
44 COMMON_EMPLOYEE_NUMBER = b"1000"
45
46
47 def _regular_user_dn(user_no):
48 """Return uid and DN for a test user under ou=regular."""
49 uid = f"{USER_UID_PREFIX}{user_no}"
50 return uid, f"uid={uid},{BASE_REGULAR}"
51
52
53 def _employeenumber_user_get_dn(no):
54 """Return employeeNumber RDN value and DN under ou=distinguished."""
55 employee_number = str(no)
56 dn = f"employeeNumber={employee_number},{BASE_DISTINGUISHED}"
57 return employee_number, dn
58
59
60 def pause_supplier_pair_isolated(m1, m2, m3):
61 """Pause all agreements touching M1 or M2 so only M3 receives later updates."""
62 agreement_m1_m2 = m1.agreement.list(
63 suffix=DEFAULT_SUFFIX, consumer_host=m2.host, consumer_port=m2.port
64 )
65 agreement_m1_m3 = m1.agreement.list(
66 suffix=DEFAULT_SUFFIX, consumer_host=m3.host, consumer_port=m3.port
67 )
68 agreement_m2_m1 = m2.agreement.list(
69 suffix=DEFAULT_SUFFIX, consumer_host=m1.host, consumer_port=m1.port
70 )
71 agreement_m2_m3 = m2.agreement.list(
72 suffix=DEFAULT_SUFFIX, consumer_host=m3.host, consumer_port=m3.port
73 )
74 m1.agreement.pause(agreement_m1_m2[0].dn)
75 m1.agreement.pause(agreement_m1_m3[0].dn)
76 m2.agreement.pause(agreement_m2_m1[0].dn)
77 m2.agreement.pause(agreement_m2_m3[0].dn)
78 return agreement_m1_m2, agreement_m1_m3, agreement_m2_m1, agreement_m2_m3
79
80
81 def resume_m2_before_m1(m1, m2, agreement_m2_m1, agreement_m2_m3, agreement_m1_m2, agreement_m1_m3):
82 """Resume M2 replication agreements to M1/M3, then M1 agreements to M2/M3."""
83 repl = ReplicationManager(DEFAULT_SUFFIX)
84
85 for ra in (agreement_m2_m1, agreement_m2_m3):
86 m2.agreement.resume(ra[0].dn)
87 repl.wait_for_replication(m2, m1)
88 for ra in (agreement_m1_m2, agreement_m1_m3):
89 m1.agreement.resume(ra[0].dn)
90
91
92 def resume_m2_then_m1_mesh(m1, m2, m3):
93 """Look up agreements and resume M2 outbound links before M1 outbound links."""
94 repl = ReplicationManager(DEFAULT_SUFFIX)
95
96 agreement_m1_m2 = m1.agreement.list(
97 suffix=DEFAULT_SUFFIX, consumer_host=m2.host, consumer_port=m2.port
98 )
99 agreement_m1_m3 = m1.agreement.list(
100 suffix=DEFAULT_SUFFIX, consumer_host=m3.host, consumer_port=m3.port
101 )
102 agreement_m2_m1 = m2.agreement.list(
103 suffix=DEFAULT_SUFFIX, consumer_host=m1.host, consumer_port=m1.port
104 )
105 agreement_m2_m3 = m2.agreement.list(
106 suffix=DEFAULT_SUFFIX, consumer_host=m3.host, consumer_port=m3.port
107 )
108 for ra in (agreement_m2_m1, agreement_m2_m3):
109 m2.agreement.resume(ra[0].dn)
110 repl.wait_for_replication(m2, m1)
111 for ra in (agreement_m1_m2, agreement_m1_m3):
112 m1.agreement.resume(ra[0].dn)
113 repl.wait_for_replication(m1, m2)
114
115
116 def resume_m1_then_m2_mesh(m1, m2, m3):
117 """Look up agreements and resume M1 outbound links before M2 outbound links."""
118 repl = ReplicationManager(DEFAULT_SUFFIX)
119
120 agreement_m1_m2 = m1.agreement.list(
121 suffix=DEFAULT_SUFFIX, consumer_host=m2.host, consumer_port=m2.port
122 )
123 agreement_m1_m3 = m1.agreement.list(
124 suffix=DEFAULT_SUFFIX, consumer_host=m3.host, consumer_port=m3.port
125 )
126 agreement_m2_m1 = m2.agreement.list(
127 suffix=DEFAULT_SUFFIX, consumer_host=m1.host, consumer_port=m1.port
128 )
129 agreement_m2_m3 = m2.agreement.list(
130 suffix=DEFAULT_SUFFIX, consumer_host=m3.host, consumer_port=m3.port
131 )
132 for ra in (agreement_m1_m2, agreement_m1_m3):
133 m1.agreement.resume(ra[0].dn)
134 repl.wait_for_replication(m1, m2)
135 for ra in (agreement_m2_m1, agreement_m2_m3):
136 m2.agreement.resume(ra[0].dn)
137 repl.wait_for_replication(m2, m1)
138
139
140 def assert_regular_employee_number_all_suppliers(m1, m2, m3, expected):
141 """Assert one regular user has the expected employeeNumber on all three suppliers."""
142 filt = f"(employeeNumber={expected})"
143 for inst, label in ((m1, "M1"), (m2, "M2"), (m3, "M3")):
144 users = UserAccounts(inst, DEFAULT_SUFFIX, rdn=f'ou=regular,ou=people')
145 ents = users.filter(filt)
146 assert len(ents) == 1, label
147 assert ents[0].present("employeeNumber")
148 assert ents[0].get_attr_val_utf8("employeeNumber") == expected, label
149
150 users = UserAccounts(m3, DEFAULT_SUFFIX, rdn=f'ou=regular,ou=people')
151 ents = users.filter("(employeeNumber=*)")
152 assert len(ents) == MAX_STANDARD_USER
153
154
155 def assert_distinguished_employee_number_all_suppliers(m1, m2, m3, expected):
156 """Assert one distinguished entry has the expected employeeNumber on all suppliers."""
157 filt = f"(employeeNumber={expected})"
158 for inst, label in ((m1, "M1"), (m2, "M2"), (m3, "M3")):
159 users = UserAccounts(inst, DEFAULT_SUFFIX, rdn=f'ou=distinguished,ou=people')
160 ents = users.filter(filt)
161 assert len(ents) == 1, label
162 assert ents[0].present("employeeNumber")
163 assert ents[0].get_attr_val_utf8("employeeNumber") == expected, label
164 users = UserAccounts(m3, DEFAULT_SUFFIX, rdn=f'ou=distinguished,ou=people')
165 ents = users.filter("(employeeNumber=*)")
166 assert len(ents) == MAX_EMPLOYEENUMBER_USER
167
168
169 def _distinguished_user_accounts(m1, m2):
170 """Return UserAccounts instances for ou=distinguished on M1 and M2."""
171 rdn = "ou=distinguished,ou=people"
172 return (
173 UserAccounts(m1, DEFAULT_SUFFIX, rdn=rdn),
174 UserAccounts(m2, DEFAULT_SUFFIX, rdn=rdn),
175 )
176
177
178 def _assert_one_distinguished(users, employee_number):
179 """Assert exactly one distinguished entry matches the employeeNumber."""
180 ents = users.filter(f"(employeeNumber={employee_number})")
181 assert len(ents) == 1
182
183
184 def _bootstrap_employee_number_dataset(topology):
185 """Create distinguished and regular test users on M3 and verify full-mesh replication."""
186 m1 = topology.ms["supplier1"]
187 m2 = topology.ms["supplier2"]
188 m3 = topology.ms["supplier3"]
189
190 ous = OrganizationalUnits(m3, DEFAULT_SUFFIX)
191 if not ous.exists("People"):
192 ous.create(properties={"ou": "People"})
193 ous_people = OrganizationalUnits(m3, BASE_PEOPLE)
194 if not ous_people.exists("distinguished"):
195 ous_people.create(properties={"ou": "distinguished"})
196 if not ous_people.exists("regular"):
197 ous_people.create(properties={"ou": "regular"})
198
199 users = UserAccounts(m3, DEFAULT_SUFFIX, rdn=f'ou=distinguished,ou=people')
200 for i in range(MAX_EMPLOYEENUMBER_USER):
201 en = str(EMPLOYEENUMBER_RDN_START + i)
202 rdn = f"employeeNumber={en}"
203 uid = str(i)
204
205 users.create(rdn=rdn, properties={
206 "uid": uid,
207 "sn": uid,
208 "cn": uid,
209 "employeeNumber": en,
210 "uidNumber": f"10{i}",
211 "gidNumber": f"100{i}",
212 "homeDirectory": f"/home/{uid}",
213 })
214
215 users = UserAccounts(m3, DEFAULT_SUFFIX, rdn=f'ou=regular,ou=people')
216 for i in range(MAX_STANDARD_USER):
217 uid = f"{USER_UID_PREFIX}{i}"
218 user = users.create(properties={
219 "uid": uid,
220 "sn": uid,
221 "cn": uid,
222 "employeeNumber": INITIAL_EMPLOYEE_NUMBER.decode(),
223 "uidNumber": f"10{i}",
224 "gidNumber": f"100{i}",
225 "homeDirectory": f"/home/{uid}",
226 })
227
228 user.replace("employeeNumber", COMMON_EMPLOYEE_NUMBER.decode())
229
230 repl = ReplicationManager(DEFAULT_SUFFIX)
231 repl.test_replication_topology([m1, m2, m3], timeout=120)
232
233 users = UserAccounts(m2, DEFAULT_SUFFIX)
234 ents = users.filter("(employeeNumber=*)")
235 assert len(ents) == MAX_USER
236
237
238 @pytest.fixture(scope="module")
239 def topology_m3_employee_number_conflict(request):
240 """Provide three suppliers with a replicated employeeNumber conflict test dataset."""
241 topology = create_topology({ReplicaRole.SUPPLIER: 3}, request=request)
242 _bootstrap_employee_number_dataset(topology)
243
244 def fin():
245 users = UserAccounts(topology.ms["supplier1"], DEFAULT_SUFFIX)
246 for user in users.filter("(employeeNumber=*)"):
247 user.delete()
248 ous = OrganizationalUnits(topology.ms["supplier1"], DEFAULT_SUFFIX)
249 ous.get("distinguished").delete()
250 ous.get("regular").delete()
251 repl = ReplicationManager(DEFAULT_SUFFIX)
252 repl.wait_for_replication(topology.ms["supplier1"], topology.ms["supplier2"])
253 repl.wait_for_replication(topology.ms["supplier1"], topology.ms["supplier3"])
254
255 users = UserAccounts(topology.ms["supplier2"], DEFAULT_SUFFIX)
256 assert len(users.filter("(employeeNumber=*)")) == 0
257 users = UserAccounts(topology.ms["supplier3"], DEFAULT_SUFFIX)
258 assert len(users.filter("(employeeNumber=*)")) == 0
259
260 request.addfinalizer(fin)
261
262 return topology
263
264
265 @pytest.mark.parametrize(
266 "user_no,m1_modifies_first,mod_kind",
267 [
268 (0, True, "DEL_ADD"),
269 (1, False, "DEL_ADD"),
270 (2, False, "ADD_DEL"),
271 (3, True, "ADD_DEL"),
272 (4, True, "M1_ADD_DEL_M2_REPLACE"),
273 (5, True, "M1_REPLACE_M2_ADD_DEL"),
274 ],
275 )
276 def test_regular_user_identical_final_value_ordering(
277 topology_m3_employee_number_conflict, user_no, m1_modifies_first, mod_kind
278 ):
279 """Check conflict resolution when M1 and M2 apply the same employeeNumber change.
280
281 :id: 79662e57-068d-4664-87cd-32d2e7ec369e
282 :setup: Three suppliers with regular users having employeeNumber=1000
283 :steps:
284 1. Pause replication agreements on M1 and M2
285 2. Apply the same modify shape on M1 and M2 for the chosen user
286 3. Resume M2 agreements to M3, then M1 agreements to M3
287 4. Verify employeeNumber on M1, M2, and M3
288 :expectedresults:
289 1. M1 and M2 are isolated from each other and from M3
290 2. Both suppliers hold the conflicting update locally
291 3. M3 receives M2's update before M1's update
292 4. All suppliers show the same final employeeNumber for that user
293 """
294 m1 = topology_m3_employee_number_conflict.ms["supplier1"]
295 m2 = topology_m3_employee_number_conflict.ms["supplier2"]
296 m3 = topology_m3_employee_number_conflict.ms["supplier3"]
297 _, test_user_dn = _regular_user_dn(user_no)
298 value_end = str(user_no).encode()
299 filt = f"(employeeNumber={user_no})"
300
301 agreement_m1_m2, agreement_m1_m3, agreement_m2_m1, agreement_m2_m3 = pause_supplier_pair_isolated(
302 m1, m2, m3
303 )
304
305 users1 = UserAccounts(m1, DEFAULT_SUFFIX, rdn=f'ou=regular,ou=people')
306 users2 = UserAccounts(m2, DEFAULT_SUFFIX, rdn=f'ou=regular,ou=people')
307
308 def mod_del_add(user):
309 user.apply_mods([
310 (ldap.MOD_DELETE, "employeeNumber", COMMON_EMPLOYEE_NUMBER),
311 (ldap.MOD_ADD, "employeeNumber", value_end)])
312
313 def mod_add_del(user):
314 user.apply_mods([
315 (ldap.MOD_ADD, "employeeNumber", value_end),
316 (ldap.MOD_DELETE, "employeeNumber", COMMON_EMPLOYEE_NUMBER)])
317
318 def mod_replace(user):
319 user.replace("employeeNumber", value_end)
320
321 if mod_kind == "DEL_ADD":
322 first, second = (mod_del_add, mod_del_add)
323 elif mod_kind == "ADD_DEL":
324 first, second = (mod_add_del, mod_add_del)
325 elif mod_kind == "M1_ADD_DEL_M2_REPLACE":
326 first, second = (mod_add_del, mod_replace)
327 elif mod_kind == "M1_REPLACE_M2_ADD_DEL":
328 first, second = (mod_replace, mod_add_del)
329 else:
330 raise AssertionError(mod_kind)
331
332 if m1_modifies_first:
333 user1 = users1.get(dn=test_user_dn)
334 first(user1)
335 assert len(users1.filter(filt)) == 1
336 time.sleep(1)
337
338 user2 = users2.get(dn=test_user_dn)
339 second(user2)
340 assert len(users2.filter(filt)) == 1
341 time.sleep(1)
342 else:
343 user2 = users2.get(dn=test_user_dn)
344 first(user2)
345 assert len(users2.filter(filt)) == 1
346 time.sleep(1)
347
348 user1 = users1.get(dn=test_user_dn)
349 second(user1)
350 assert len(users1.filter(filt)) == 1
351 time.sleep(1)
352
353 resume_m2_before_m1(
354 m1, m2, agreement_m2_m1, agreement_m2_m3, agreement_m1_m2, agreement_m1_m3
355 )
356 assert_regular_employee_number_all_suppliers(m1, m2, m3, str(user_no))
357
358
359 def _build_mixed_mods(user_no, s1_kind, s2_kind):
360 """Build LDAP mod lists for two different single-valued employeeNumber update shapes."""
361 v1000 = b"1000"
362 s1 = f"{user_no}.1".encode()
363 s2 = f"{user_no}.2".encode()
364 m1 = None
365 m2 = None
366 if s1_kind == "REPLACE":
367 m1 = [(ldap.MOD_REPLACE, "employeeNumber", s1)]
368 elif s1_kind == "ADD_DEL":
369 m1 = [(ldap.MOD_ADD, "employeeNumber", s1), (ldap.MOD_DELETE, "employeeNumber", v1000)]
370 elif s1_kind == "DEL_ADD":
371 m1 = [(ldap.MOD_DELETE, "employeeNumber", v1000), (ldap.MOD_ADD, "employeeNumber", s1)]
372 if s2_kind == "REPLACE":
373 m2 = [(ldap.MOD_REPLACE, "employeeNumber", s2)]
374 elif s2_kind == "ADD_DEL":
375 m2 = [(ldap.MOD_ADD, "employeeNumber", s2), (ldap.MOD_DELETE, "employeeNumber", v1000)]
376 elif s2_kind == "DEL_ADD":
377 m2 = [(ldap.MOD_DELETE, "employeeNumber", v1000), (ldap.MOD_ADD, "employeeNumber", s2)]
378 return m1, m2
379
380
381 @pytest.mark.parametrize(
382 "user_no,first_server,s1_kind,s2_kind,expected",
383 [
384 (6, "M1", "REPLACE", "ADD_DEL", "6.2"),
385 (7, "M1", "ADD_DEL", "REPLACE", "7.2"),
386 (8, "M1", "DEL_ADD", "REPLACE", "8.2"),
387 (9, "M1", "REPLACE", "DEL_ADD", "9.2"),
388 (10, "M1", "REPLACE", "REPLACE", "10.2"),
389 (11, "M2", "REPLACE", "REPLACE", "11.1"),
390 (12, "M2", "REPLACE", "ADD_DEL", "12.1"),
391 (13, "M2", "REPLACE", "DEL_ADD", "13.1"),
392 (14, "M2", "DEL_ADD", "DEL_ADD", "14.1"),
393 (15, "M2", "ADD_DEL", "DEL_ADD", "15.1"),
394 ],
395 )
396 def test_regular_user_mixed_modify_shapes(
397 topology_m3_employee_number_conflict, user_no, first_server, s1_kind, s2_kind, expected
398 ):
399 """Check conflict resolution when M1 and M2 use different modify shapes.
400
401 :id: cdcdac34-bbf6-42ce-800e-954e21f0ba1d
402 :setup: Three suppliers with regular users having employeeNumber=1000
403 :steps:
404 1. Pause replication agreements on M1 and M2
405 2. Apply distinct modify shapes on M1 and M2 for the chosen user
406 3. Resume M2 agreements to M3, then M1 agreements to M3
407 4. Verify the expected employeeNumber on M1, M2, and M3
408 :expectedresults:
409 1. M1 and M2 are isolated from each other and from M3
410 2. Each supplier holds its local conflicting value
411 3. M3 receives M2's update before M1's update
412 4. All suppliers converge on the parametrized winning value
413 """
414 m1 = topology_m3_employee_number_conflict.ms["supplier1"]
415 m2 = topology_m3_employee_number_conflict.ms["supplier2"]
416 m3 = topology_m3_employee_number_conflict.ms["supplier3"]
417 _, test_user_dn = _regular_user_dn(user_no)
418 s1_mod, s2_mod = _build_mixed_mods(user_no, s1_kind, s2_kind)
419 value_s1 = f"{user_no}.1"
420 value_s2 = f"{user_no}.2"
421
422 agreement_m1_m2, agreement_m1_m3, agreement_m2_m1, agreement_m2_m3 = pause_supplier_pair_isolated(
423 m1, m2, m3
424 )
425
426 users1 = UserAccounts(m1, DEFAULT_SUFFIX, rdn="ou=regular,ou=people")
427 users2 = UserAccounts(m2, DEFAULT_SUFFIX, rdn="ou=regular,ou=people")
428 user1 = users1.get(dn=test_user_dn)
429 user2 = users2.get(dn=test_user_dn)
430 if first_server == "M1":
431 user1.apply_mods(s1_mod)
432 assert len(users1.filter(f"(employeeNumber={value_s1})")) == 1
433 time.sleep(1)
434 user2.apply_mods(s2_mod)
435 assert len(users2.filter(f"(employeeNumber={value_s2})")) == 1
436 else:
437 user2.apply_mods(s2_mod)
438 assert len(users2.filter(f"(employeeNumber={value_s2})")) == 1
439 time.sleep(1)
440 user1.apply_mods(s1_mod)
441 assert len(users1.filter(f"(employeeNumber={value_s1})")) == 1
442
443 resume_m2_before_m1(
444 m1, m2, agreement_m2_m1, agreement_m2_m3, agreement_m1_m2, agreement_m1_m3
445 )
446 assert_regular_employee_number_all_suppliers(m1, m2, m3, expected)
447
448
449 def test_distinguished_modrdn_same_new_rdn_resume_m2_first(topology_m3_employee_number_conflict):
450 """Check MODRDN conflict when M1 and M2 choose the same new employeeNumber RDN.
451
452 :id: a54235dd-7951-478e-bfe0-3683986b18aa
453 :setup: Three suppliers with distinguished employeeNumber RDN entries
454 :steps:
455 1. Pause replication agreements on M1 and M2
456 2. MODRDN the same entry on M1 and M2 to the same new RDN value
457 3. Resume M2 agreements, then M1 agreements
458 4. Verify employeeNumber on all suppliers
459 :expectedresults:
460 1. M1 and M2 are isolated during the updates
461 2. Both suppliers rename the entry to the same RDN locally
462 3. M3 receives M2's change before M1's change
463 4. All suppliers show the shared final employeeNumber value
464 """
465 m1 = topology_m3_employee_number_conflict.ms["supplier1"]
466 m2 = topology_m3_employee_number_conflict.ms["supplier2"]
467 m3 = topology_m3_employee_number_conflict.ms["supplier3"]
468 value_s1 = value_s2 = "1.1"
469 _, test_user_dn = _employeenumber_user_get_dn(1)
470 pause_supplier_pair_isolated(m1, m2, m3)
471
472 users1, users2 = _distinguished_user_accounts(m1, m2)
473 users1.get(dn=test_user_dn).rename(
474 f"employeeNumber={value_s1}",
475 deloldrdn=1,
476 )
477 _assert_one_distinguished(users1, value_s1)
478 time.sleep(1)
479
480 users2.get(dn=test_user_dn).rename(
481 f"employeeNumber={value_s2}",
482 deloldrdn=1,
483 )
484 _assert_one_distinguished(users2, value_s2)
485 resume_m2_then_m1_mesh(m1, m2, m3)
486 assert_distinguished_employee_number_all_suppliers(m1, m2, m3, value_s1)
487
488
489 def test_distinguished_modrdn_divergent_rdn_resume_m2_first(topology_m3_employee_number_conflict):
490 """Check MODRDN conflict when M1 and M2 choose different employeeNumber RDN values.
491
492 :id: 1f3ccb99-10a5-47a1-a3a1-45386ec7a368
493 :setup: Three suppliers with distinguished employeeNumber RDN entries
494 :steps:
495 1. Pause replication agreements on M1 and M2
496 2. MODRDN the entry on M1 and M2 to different new RDN values
497 3. Resume M2 agreements, then M1 agreements
498 4. Verify employeeNumber on all suppliers
499 :expectedresults:
500 1. M1 and M2 are isolated during the updates
501 2. Each supplier holds a different renamed entry locally
502 3. M3 receives M2's RDN before M1's RDN
503 4. M2's employeeNumber value wins on all suppliers
504 """
505 m1 = topology_m3_employee_number_conflict.ms["supplier1"]
506 m2 = topology_m3_employee_number_conflict.ms["supplier2"]
507 m3 = topology_m3_employee_number_conflict.ms["supplier3"]
508 value_s1, value_s2 = "2.1", "2.2"
509 _, test_user_dn = _employeenumber_user_get_dn(2)
510 pause_supplier_pair_isolated(m1, m2, m3)
511
512 users1, users2 = _distinguished_user_accounts(m1, m2)
513 users1.get(dn=test_user_dn).rename(
514 f"employeeNumber={value_s1}",
515 deloldrdn=1,
516 )
517 time.sleep(1)
518 users2.get(dn=test_user_dn).rename(
519 f"employeeNumber={value_s2}",
520 deloldrdn=1,
521 )
522 resume_m2_then_m1_mesh(m1, m2, m3)
523 assert_distinguished_employee_number_all_suppliers(m1, m2, m3, value_s2)
524
525
526 def test_distinguished_modrdn_divergent_rdn_resume_m1_first(topology_m3_employee_number_conflict):
527 """Check MODRDN conflict with divergent RDNs when M1 replicates to M3 first.
528
529 :id: de14af98-f943-4e67-96f8-1e67592f351a
530 :setup: Three suppliers with distinguished employeeNumber RDN entries
531 :steps:
532 1. Pause replication agreements on M1 and M2
533 2. MODRDN the entry on M1 and M2 to different new RDN values
534 3. Resume M1 agreements, then M2 agreements
535 4. Verify employeeNumber on all suppliers
536 :expectedresults:
537 1. M1 and M2 are isolated during the updates
538 2. Each supplier holds a different renamed entry locally
539 3. M3 receives M1's RDN before M2's RDN
540 4. M2's employeeNumber value still wins on all suppliers
541 """
542 m1 = topology_m3_employee_number_conflict.ms["supplier1"]
543 m2 = topology_m3_employee_number_conflict.ms["supplier2"]
544 m3 = topology_m3_employee_number_conflict.ms["supplier3"]
545 value_s1, value_s2 = "3.1", "3.2"
546 _, test_user_dn = _employeenumber_user_get_dn(3)
547 pause_supplier_pair_isolated(m1, m2, m3)
548
549 users1, users2 = _distinguished_user_accounts(m1, m2)
550 users1.get(dn=test_user_dn).rename(
551 f"employeeNumber={value_s1}",
552 deloldrdn=1,
553 )
554 time.sleep(1)
555 users2.get(dn=test_user_dn).rename(
556 f"employeeNumber={value_s2}",
557 deloldrdn=1,
558 )
559 resume_m1_then_m2_mesh(m1, m2, m3)
560 assert_distinguished_employee_number_all_suppliers(m1, m2, m3, value_s2)
561
562
563 def test_distinguished_modrdn_then_replace_resume_m2_first(topology_m3_employee_number_conflict):
564 """Check MODRDN conflict followed by M1 MOD(REPLACE) with M2 replicating first.
565
566 :id: 4c6d761e-fead-4f05-98c1-b2aafea0e926
567 :setup: Three suppliers with distinguished employeeNumber RDN entries
568 :steps:
569 1. Pause replication agreements on M1 and M2
570 2. MODRDN the entry on M1 and M2 to different new RDN values
571 3. On M1, MOD(REPLACE) employeeNumber back to the M1 RDN value
572 4. Resume M2 agreements, then M1 agreements
573 5. Verify employeeNumber on all suppliers
574 :expectedresults:
575 1. M1 and M2 are isolated during the updates
576 2. M1 holds a replace on its renamed entry
577 3. M3 receives M2's updates before M1's replace
578 4. M1's employeeNumber value wins on all suppliers
579 """
580 m1 = topology_m3_employee_number_conflict.ms["supplier1"]
581 m2 = topology_m3_employee_number_conflict.ms["supplier2"]
582 m3 = topology_m3_employee_number_conflict.ms["supplier3"]
583 value_s1, value_s2 = "4.1", "4.2"
584 _, test_user_dn = _employeenumber_user_get_dn(4)
585 pause_supplier_pair_isolated(m1, m2, m3)
586
587 users1, users2 = _distinguished_user_accounts(m1, m2)
588 user1 = users1.get(dn=test_user_dn)
589 user1.rename(f"employeeNumber={value_s1}", deloldrdn=1)
590 time.sleep(1)
591 users2.get(dn=test_user_dn).rename(
592 f"employeeNumber={value_s2}",
593 deloldrdn=1,
594 )
595 time.sleep(1)
596
597 _, dn_s1 = _employeenumber_user_get_dn(value_s1)
598 users1.get(dn=dn_s1).replace("employeeNumber", value_s1)
599 _assert_one_distinguished(users1, value_s1)
600 resume_m2_then_m1_mesh(m1, m2, m3)
601 assert_distinguished_employee_number_all_suppliers(m1, m2, m3, value_s1)
602
603
604
605 # --- extended distinguished employeeNumber RDN scenarios ---
606
607 def _mod_replace_employee_number(value):
608 """Return a MOD_REPLACE mod list for employeeNumber."""
609 return [(ldap.MOD_REPLACE, "employeeNumber", value.encode())]
610
611
612 def _mod_del_add_employee_number(value):
613 """Return a MOD_DELETE/MOD_ADD mod list for employeeNumber."""
614 return [
615 (ldap.MOD_DELETE, "employeeNumber", value.encode()),
616 (ldap.MOD_ADD, "employeeNumber", value.encode()),
617 ]
618
619
620 def _employee_number_mod_for_kind(kind, value):
621 """Map a mod kind name to the corresponding employeeNumber mod list."""
622 if kind == "REPLACE":
623 return _mod_replace_employee_number(value)
624 if kind == "DEL_ADD":
625 return _mod_del_add_employee_number(value)
626 raise AssertionError(f"unknown mod kind: {kind}")
627
628
629 def _resume_mesh_for_order(resume_order):
630 """Return the mesh resume helper for the requested supplier order."""
631 if resume_order == "m1_first":
632 return resume_m1_then_m2_mesh
633 if resume_order == "m2_first":
634 return resume_m2_then_m1_mesh
635 raise AssertionError(f"unknown resume order: {resume_order}")
636
637
638 def _run_distinguished_employee_rdn_scenario(
639 m1,
640 m2,
641 m3,
642 user_index,
643 value_s1,
644 value_s2,
645 s1_mod,
646 resume_fn,
647 expected,
648 s2_mod=None,
649 m2_final_modrdn=None,
650 ):
651 """Run isolated MODRDN/MOD steps on distinguished entries and verify convergence."""
652 _, test_user_dn = _employeenumber_user_get_dn(user_index)
653 pause_supplier_pair_isolated(m1, m2, m3)
654 users1, users2 = _distinguished_user_accounts(m1, m2)
655
656 user1 = users1.get(dn=test_user_dn)
657 user1.rename(f"employeeNumber={value_s1}", deloldrdn=1)
658 _assert_one_distinguished(users1, value_s1)
659 time.sleep(1)
660
661 user2 = users2.get(dn=test_user_dn)
662 user2.rename(f"employeeNumber={value_s2}", deloldrdn=1)
663 _assert_one_distinguished(users2, value_s2)
664 time.sleep(1)
665
666 if s1_mod is not None:
667 _, dn_s1 = _employeenumber_user_get_dn(value_s1)
668 user1 = users1.get(dn=dn_s1)
669 user1.apply_mods(s1_mod)
670 _assert_one_distinguished(users1, value_s1)
671
672 if s2_mod is not None:
673 time.sleep(1)
674 _, dn_s2 = _employeenumber_user_get_dn(value_s2)
675 user2 = users2.get(dn=dn_s2)
676 user2.apply_mods(s2_mod)
677 _assert_one_distinguished(users2, value_s2)
678
679 if m2_final_modrdn is not None:
680 time.sleep(1)
681 _, dn_s2 = _employeenumber_user_get_dn(value_s2)
682 user2 = users2.get(dn=dn_s2)
683 user2.rename(f"employeeNumber={m2_final_modrdn}", deloldrdn=1)
684 _assert_one_distinguished(users2, m2_final_modrdn)
685
686 resume_fn(m1, m2, m3)
687 assert_distinguished_employee_number_all_suppliers(m1, m2, m3, expected)
688
689
690 @pytest.mark.parametrize(
691 "user_index,s1_mod_kind,s2_mod_kind,resume_order,expected_key,m2_final_to_s1,scenario_description",
692 [
693 pytest.param(
694 5, "REPLACE", None, "m1_first", "s1", False,
695 "M1/M2 MODRDN to V1/V2, M1 MOD(REPL)->V1; resume M1 then M2; expect V1",
696 id="01_m1_repl_resume_m1_expect_v1",
697 ),
698 pytest.param(
699 6, "DEL_ADD", None, "m2_first", "s1", False,
700 "M1/M2 MODRDN to V1/V2, M1 MOD(DEL/ADD)->V1; resume M2 then M1; expect V1",
701 id="02_m1_del_add_resume_m2_expect_v1",
702 ),
703 pytest.param(
704 7, "DEL_ADD", None, "m1_first", "s1", False,
705 "M1/M2 MODRDN to V1/V2, M1 MOD(DEL/ADD)->V1; resume M1 then M2; expect V1",
706 id="03_m1_del_add_resume_m1_expect_v1",
707 ),
708 pytest.param(
709 8, "REPLACE", "REPLACE", "m2_first", "s2", False,
710 "M1/M2 MODRDN, M1 MOD(REPL)->V1, M2 MOD(REPL)->V2; resume M2 then M1; expect V2",
711 id="04_m1_m2_repl_resume_m2_expect_v2",
712 ),
713 pytest.param(
714 9, "REPLACE", "REPLACE", "m1_first", "s2", False,
715 "M1/M2 MODRDN, M1 MOD(REPL)->V1, M2 MOD(REPL)->V2; resume M1 then M2; expect V2",
716 id="05_m1_m2_repl_resume_m1_expect_v2",
717 ),
718 pytest.param(
719 10, "REPLACE", "DEL_ADD", "m1_first", "s2", False,
720 "M1/M2 MODRDN, M1 MOD(REPL)->V1, M2 MOD(DEL/ADD)->V2; resume M1 then M2; expect V2",
721 id="06_m1_repl_m2_del_add_resume_m1_expect_v2",
722 ),
723 pytest.param(
724 11, "REPLACE", "DEL_ADD", "m2_first", "s2", False,
725 "M1/M2 MODRDN, M1 MOD(REPL)->V1, M2 MOD(DEL/ADD)->V2; resume M2 then M1; expect V2",
726 id="07_m1_repl_m2_del_add_resume_m2_expect_v2",
727 ),
728 pytest.param(
729 12, "DEL_ADD", "REPLACE", "m1_first", "s2", False,
730 "M1/M2 MODRDN, M1 MOD(DEL/ADD)->V1, M2 MOD(REPL)->V2; resume M1 then M2; expect V2",
731 id="08_m1_del_add_m2_repl_resume_m1_expect_v2",
732 ),
733 pytest.param(
734 13, "DEL_ADD", "REPLACE", "m2_first", "s2", False,
735 "M1/M2 MODRDN, M1 MOD(DEL/ADD)->V1, M2 MOD(REPL)->V2; resume M2 then M1; expect V2",
736 id="09_m1_del_add_m2_repl_resume_m2_expect_v2",
737 ),
738 pytest.param(
739 14, "DEL_ADD", "DEL_ADD", "m1_first", "s2", False,
740 "M1/M2 MODRDN, both MOD(DEL/ADD); resume M1 then M2; expect V2",
741 id="10_both_del_add_resume_m1_expect_v2",
742 ),
743 pytest.param(
744 15, "DEL_ADD", "DEL_ADD", "m2_first", "s2", False,
745 "M1/M2 MODRDN, both MOD(DEL/ADD); resume M2 then M1; expect V2",
746 id="11_both_del_add_resume_m2_expect_v2",
747 ),
748 pytest.param(
749 16, "REPLACE", "REPLACE", "m2_first", "s1", True,
750 "M1/M2 MODRDN, both MOD(REPL), M2 MODRDN->V1; resume M2 then M1; expect V1",
751 id="12_m2_repl_then_modrdn_v1_resume_m2_expect_v1",
752 ),
753 pytest.param(
754 17, "REPLACE", "REPLACE", "m1_first", "s1", True,
755 "M1/M2 MODRDN, both MOD(REPL), M2 MODRDN->V1; resume M1 then M2; expect V1",
756 id="13_m2_repl_then_modrdn_v1_resume_m1_expect_v1",
757 ),
758 pytest.param(
759 18, "REPLACE", None, "m2_first", "s1", True,
760 "M1/M2 MODRDN, M1 MOD(REPL)->V1, M2 MODRDN->V1; resume M2 then M1; expect V1",
761 id="14_m1_repl_m2_modrdn_v1_resume_m2_expect_v1",
762 ),
763 pytest.param(
764 19, "REPLACE", None, "m1_first", "s1", True,
765 "M1/M2 MODRDN, M1 MOD(REPL)->V1, M2 MODRDN->V1; resume M1 then M2; expect V1",
766 id="15_m1_repl_m2_modrdn_v1_resume_m1_expect_v1",
767 ),
768 ],
769 )
770 def test_distinguished_employee_rdn_scenario(
771 topology_m3_employee_number_conflict,
772 user_index,
773 s1_mod_kind,
774 s2_mod_kind,
775 resume_order,
776 expected_key,
777 m2_final_to_s1,
778 scenario_description,
779 ):
780 """Check parametrized MODRDN and MOD conflicts on distinguished entries.
781
782 :id: f3835f41-9d21-4c24-94b4-3d6b1c2cdd6f
783 :setup: Three suppliers with distinguished employeeNumber RDN entries
784 :steps:
785 1. Pause replication agreements on M1 and M2
786 2. Apply the parametrized MODRDN and MOD sequence on M1 and M2
787 3. Resume replication in the parametrized supplier order
788 4. Verify the expected employeeNumber on M1, M2, and M3
789 :expectedresults:
790 1. M1 and M2 are isolated during local updates
791 2. Conflicting changes remain local until agreements resume
792 3. M3 receives updates in the chosen resume order
793 4. All suppliers converge on the parametrized winning employeeNumber
794 """
795 log.info(f"Distinguished RDN scenario: {scenario_description}")
796 m1 = topology_m3_employee_number_conflict.ms["supplier1"]
797 m2 = topology_m3_employee_number_conflict.ms["supplier2"]
798 m3 = topology_m3_employee_number_conflict.ms["supplier3"]
799 value_s1 = f"{user_index}.1"
800 value_s2 = f"{user_index}.2"
801 expected = value_s1 if expected_key == "s1" else value_s2
802 s2_mod = (
803 _employee_number_mod_for_kind(s2_mod_kind, value_s2) if s2_mod_kind else None
804 )
805 _run_distinguished_employee_rdn_scenario(
806 m1,
807 m2,
808 m3,
809 user_index,
810 value_s1,
811 value_s2,
812 _employee_number_mod_for_kind(s1_mod_kind, value_s1),
813 _resume_mesh_for_order(resume_order),
814 expected,
815 s2_mod=s2_mod,
816 m2_final_modrdn=value_s1 if m2_final_to_s1 else None,
817 )
818
819
820 if __name__ == '__main__':
821 # Run isolated
822 # -s for DEBUG mode
823 CURRENT_FILE = os.path.realpath(__file__)
824 pytest.main(["-s", CURRENT_FILE])
825