def testComplex(self):
a = entry.BaseLDAPEntry(
dn='cn=Paula Jensen,ou=Product Development,dc=airius,dc=com',
attributes={
'description': ['Something'],
'telephonenumber': ['+123 456'],
'facsimiletelephonenumber': ['+1 408 555 9876'],
})
b = entry.BaseLDAPEntry(
dn='cn=Paula Jensen,ou=Product Development,dc=airius,dc=com',
attributes={
'postalAddress': ['123 Anystreet $ Sunnyvale, CA $ 94086'],
'telephonenumber': ['+1 408 555 1234', '+1 408 555 5678'],
})
result = a.diff(b)
self.assertEqual(
result,
delta.ModifyOp(
'cn=Paula Jensen,ou=Product Development,dc=airius,dc=com', [
delta.Add('postalAddress',
['123 Anystreet $ Sunnyvale, CA $ 94086']),
delta.Delete('description', ['Something']),
delta.Delete('facsimiletelephonenumber',
['+1 408 555 9876']),
delta.Add('telephonenumber',
['+1 408 555 1234', '+1 408 555 5678']),
delta.Delete('telephonenumber', ['+123 456']),
]))
def testModification_twoAdds(self):
proto = LDIFDeltaDriver()
proto.dataReceived(b"""\
version: 1
dn: cn=foo,dc=example,dc=com
changetype: modify
add: foo
foo: bar
-
add: thud
thud: quux
thud: baz
-
""")
proto.connectionLost()
self.assertEqual(
proto.listOfCompleted,
[
delta.ModifyOp(
dn=b"cn=foo,dc=example,dc=com",
modifications=[
delta.Add(b"foo", [b"bar"]),
delta.Add(b"thud", [b"quux", b"baz"]),
],
),
],
)
def testComplex(self):
a = entry.BaseLDAPEntry(
dn="cn=Paula Jensen,ou=Product Development,dc=airius,dc=com",
attributes={
"description": ["Something"],
"telephonenumber": ["+123 456"],
"facsimiletelephonenumber": ["+1 408 555 9876"],
},
)
b = entry.BaseLDAPEntry(
dn="cn=Paula Jensen,ou=Product Development,dc=airius,dc=com",
attributes={
"postalAddress": ["123 Anystreet $ Sunnyvale, CA $ 94086"],
"telephonenumber": ["+1 408 555 1234", "+1 408 555 5678"],
},
)
result = a.diff(b)
self.assertEqual(
result,
delta.ModifyOp(
"cn=Paula Jensen,ou=Product Development,dc=airius,dc=com",
[
delta.Add(
"postalAddress", ["123 Anystreet $ Sunnyvale, CA $ 94086"]
),
delta.Delete("description", ["Something"]),
delta.Delete("facsimiletelephonenumber", ["+1 408 555 9876"]),
delta.Add(
"telephonenumber", ["+1 408 555 1234", "+1 408 555 5678"]
),
delta.Delete("telephonenumber", ["+123 456"]),
],
),
)
def testAdd_NewAndExisting_ManyTypes(self):
a = entry.BaseLDAPEntry(
dn="dc=foo",
attributes={
"foo": ["bar"],
"baz": ["quux"],
},
)
b = entry.BaseLDAPEntry(
dn="dc=foo",
attributes={
"foo": ["bar", "thud", "bang"],
"baz": ["quux", "bar", "stump"],
"bang": ["thud", "barble"],
},
)
result = a.diff(b)
self.assertEqual(
result,
delta.ModifyOp(
"dc=foo",
[
delta.Add("bang", ["thud", "barble"]),
delta.Add("baz", ["bar", "stump"]),
delta.Add("foo", ["thud", "bang"]),
],
),
)
def cb3(got):
self.assertEquals(got, [
delta.ModifyOp(
self.empty.dn,
[delta.Add('foo', ['bar'])],
),
])
def testRootChange_Add(self):
a = inmemory.ReadOnlyInMemoryLDAPEntry(
"dc=example,dc=com",
{
"dc": ["example"],
},
)
b = inmemory.ReadOnlyInMemoryLDAPEntry(
"dc=example,dc=com",
{
"dc": ["example"],
"foo": ["bar"],
},
)
d = a.diffTree(b)
d.addCallback(
self.assertEqual,
[
delta.ModifyOp(
"dc=example,dc=com",
[
delta.Add("foo", ["bar"]),
],
),
],
)
return d
def testModify(self):
op=delta.ModifyOp('cn=Paula Jensen, ou=Product Development, dc=airius, dc=com',
[
delta.Add('postaladdress',
['123 Anystreet $ Sunnyvale, CA $ 94086']),
delta.Delete('description'),
delta.Replace('telephonenumber', ['+1 408 555 1234', '+1 408 555 5678']),
delta.Delete('facsimiletelephonenumber', ['+1 408 555 9876']),
])
self.assertEquals(op.asLDIF(),
"""\
dn: cn=Paula Jensen,ou=Product Development,dc=airius,dc=com
changetype: modify
add: postaladdress
postaladdress: 123 Anystreet $ Sunnyvale, CA $ 94086
-
delete: description
-
replace: telephonenumber
telephonenumber: +1 408 555 1234
telephonenumber: +1 408 555 5678
-
delete: facsimiletelephonenumber
facsimiletelephonenumber: +1 408 555 9876
-
""")
def test_modify(self):
self.server.dataReceived(
pureldap.LDAPMessage(
pureldap.LDAPModifyRequest(
self.stuff.dn.getText(),
modification=[
delta.Add("foo", ["bar"]).asLDAP(),
],
),
id=2,
).toWire())
self.assertEqual(
self.server.transport.value(),
pureldap.LDAPMessage(
pureldap.LDAPModifyResponse(
resultCode=ldaperrors.Success.resultCode),
id=2,
).toWire(),
)
# tree changed
self.assertEqual(
self.stuff,
inmemory.ReadOnlyInMemoryLDAPEntry(
"ou=stuff,dc=example,dc=com",
{
b"objectClass": [b"a", b"b"],
b"ou": [b"stuff"],
b"foo": [b"bar"]
},
),
)
def test_modify(self):
self.server.dataReceived(
pureldap.LDAPMessage(
pureldap.LDAPModifyRequest(
self.stuff.dn.getText(),
modification=[
delta.Add('foo', ['bar']).asLDAP(),
]),
id=2).toWire())
self.assertEqual(
self.server.transport.value(),
pureldap.LDAPMessage(
pureldap.LDAPModifyResponse(
resultCode=ldaperrors.Success.resultCode),
id=2).toWire())
# tree changed
self.assertEqual(
self.stuff,
inmemory.ReadOnlyInMemoryLDAPEntry(
'ou=stuff,dc=example,dc=com',
{
b'objectClass': [b'a', b'b'],
b'ou': [b'stuff'],
b'foo': [b'bar']
}))
def testAdd(self):
m = delta.Add('foo', ['bar', 'baz'])
self.assertEqual(m.asLDIF(), b"""\
add: foo
foo: bar
foo: baz
-
""")
def testModifyOp_DNNotFound(self):
op = delta.ModifyOp('cn=nope,dc=example,dc=com',
[delta.Add('foo', ['bar'])])
d = op.patch(self.root)
def eb(fail):
fail.trap(ldaperrors.LDAPNoSuchObject)
d.addCallbacks(testutil.mustRaise, eb)
return d
def testAdd_New_ManyTypes(self):
a = entry.BaseLDAPEntry(dn='dc=foo', attributes={
'foo': ['bar'],
})
b = entry.BaseLDAPEntry(dn='dc=foo',
attributes={
'foo': ['bar'],
'baz': ['quux'],
'bang': ['thud'],
})
result = a.diff(b)
self.assertEqual(
result,
delta.ModifyOp('dc=foo', [
delta.Add('bang', ['thud']),
delta.Add('baz', ['quux']),
]))
def testModification_complex(self):
proto = LDIFDeltaDriver()
proto.dataReceived(b"""\
version: 1
dn: cn=foo,dc=example,dc=com
changetype: modify
delete: foo
foo: bar
-
delete: garply
-
add: thud
thud: quux
thud: baz
-
replace: waldo
-
add: foo
foo: baz
-
replace: thud
thud: xyzzy
-
add: silly
-
""")
proto.connectionLost()
self.assertEqual(
proto.listOfCompleted,
[
delta.ModifyOp(
dn=b"cn=foo,dc=example,dc=com",
modifications=[
delta.Delete(b"foo", [b"bar"]),
delta.Delete(b"garply"),
delta.Add(b"thud", [b"quux", b"baz"]),
delta.Replace(b"waldo"),
delta.Add(b"foo", [b"baz"]),
delta.Replace(b"thud", [b"xyzzy"]),
delta.Add(b"silly"),
],
),
],
)
def cb3(got):
self.assertEqual(
got,
[
delta.ModifyOp(
self.empty.dn,
[delta.Add(b"foo", [b"bar"])],
),
],
)
def diff(self, other):
"""
Compute differences between this and another LDAP entry.
@param other: An LDAPEntry to compare to.
@return: None if equal, otherwise a ModifyOp that would make
this entry look like other.
"""
assert self.dn == other.dn
if self == other:
return None
r = []
myKeys = set(key for key in self)
otherKeys = set(key for key in other)
addedKeys = list(otherKeys - myKeys)
addedKeys.sort(key=to_bytes) # for reproducability only
for added in addedKeys:
r.append(delta.Add(added, other[added]))
deletedKeys = list(myKeys - otherKeys)
deletedKeys.sort(key=to_bytes) # for reproducability only
for deleted in deletedKeys:
r.append(delta.Delete(deleted, self[deleted]))
sharedKeys = list(myKeys & otherKeys)
sharedKeys.sort(key=to_bytes) # for reproducability only
for shared in sharedKeys:
addedValues = list(other[shared] - self[shared])
if addedValues:
addedValues.sort(key=to_bytes) # for reproducability only
r.append(delta.Add(shared, addedValues))
deletedValues = list(self[shared] - other[shared])
if deletedValues:
deletedValues.sort(key=to_bytes) # for reproducability only
r.append(delta.Delete(shared, deletedValues))
return delta.ModifyOp(dn=self.dn, modifications=r)
def testInequalityDifferentModifications(self):
"""
Modify operations with different modifications are not equal
"""
first = delta.ModifyOp("cn=john,dc=example,dc=com",
[delta.Add("description")])
second = delta.ModifyOp("cn=john,dc=example,dc=com",
[delta.Delete("description")])
self.assertNotEqual(first, second)
def testAdd(self):
m = delta.Add("foo", ["bar", "baz"])
self.assertEqual(
m.asLDIF(),
b"""\
add: foo
foo: bar
foo: baz
-
""",
)
def testModification_complex(self):
proto = LDIFDeltaDriver()
proto.dataReceived(b"""\
version: 1
dn: cn=foo,dc=example,dc=com
changetype: modify
delete: foo
foo: bar
-
delete: garply
-
add: thud
thud: quux
thud: baz
-
replace: waldo
-
add: foo
foo: baz
-
replace: thud
thud: xyzzy
-
add: silly
-
""")
proto.connectionLost()
self.assertEqual(proto.listOfCompleted, [
delta.ModifyOp(dn=b'cn=foo,dc=example,dc=com',
modifications=[
delta.Delete(b'foo', [b'bar']),
delta.Delete(b'garply'),
delta.Add(b'thud', [b'quux', b'baz']),
delta.Replace(b'waldo'),
delta.Add(b'foo', [b'baz']),
delta.Replace(b'thud', [b'xyzzy']),
delta.Add(b'silly'),
]),
])
def testAdd_Existing_OneType_OneValue(self):
a = entry.BaseLDAPEntry(dn='dc=foo', attributes={
'foo': ['bar'],
})
b = entry.BaseLDAPEntry(dn='dc=foo',
attributes={
'foo': ['bar', 'quux'],
})
result = a.diff(b)
self.assertEqual(
result, delta.ModifyOp('dc=foo', [
delta.Add('foo', ['quux']),
]))
def testAddBase64(self):
"""
LDIF attribute representation is base64 encoded
if attribute value contains nonprintable characters
or starts with reserved characters
"""
m = delta.Add('attr', [':value1', 'value\n\r2'])
self.assertEqual(m.asLDIF(),
b"""\
add: attr
attr:: OnZhbHVlMQ==
attr:: dmFsdWUKDTI=
-
""")
def testModification_twoAdds(self):
proto = LDIFDeltaDriver()
proto.dataReceived(b"""\
version: 1
dn: cn=foo,dc=example,dc=com
changetype: modify
add: foo
foo: bar
-
add: thud
thud: quux
thud: baz
-
""")
proto.connectionLost()
self.assertEqual(proto.listOfCompleted, [
delta.ModifyOp(dn=b'cn=foo,dc=example,dc=com',
modifications=[
delta.Add(b'foo', [b'bar']),
delta.Add(b'thud', [b'quux', b'baz']),
]),
])
def testModifyOp_DNNotFound(self):
"""
If fail to modify when the RDN does not exists.
"""
root = self.getRoot()
sut = delta.ModifyOp(
'cn=nope,dc=example,dc=com',
[delta.Add('foo', ['bar'])],
)
deferred = sut.patch(root)
failure = self.failureResultOf(deferred)
self.assertIsInstance(failure.value, ldaperrors.LDAPNoSuchObject)
def testRootChange_Add(self):
a = inmemory.ReadOnlyInMemoryLDAPEntry('dc=example,dc=com', {
'dc': ['example'],
})
b = inmemory.ReadOnlyInMemoryLDAPEntry('dc=example,dc=com', {
'dc': ['example'],
'foo': ['bar'],
})
d = a.diffTree(b)
d.addCallback(self.assertEquals, [
delta.ModifyOp('dc=example,dc=com', [
delta.Add('foo', ['bar']),
]),
])
return d
def testModification_oneAdd(self):
proto = LDIFDeltaDriver()
proto.dataReceived(b"""\
version: 1
dn: cn=foo,dc=example,dc=com
changetype: modify
add: foo
foo: bar
-
""")
proto.connectionLost()
self.assertEqual(proto.listOfCompleted, [
delta.ModifyOp(dn='cn=foo,dc=example,dc=com',
modifications=[
delta.Add('foo', ['bar']),
]),
])
def testAsLDIF(self):
"""
It will return a LDIF representation of the contained operations.
"""
sut = delta.ModifyOp(
'cn=Paula Jensen, ou=Dev Ops, dc=airius, dc=com',
[
delta.Add(
'postaladdress',
['123 Anystreet $ Sunnyvale, CA $ 94086'],
),
delta.Delete('description'),
delta.Replace(
'telephonenumber',
['+1 408 555 1234', '+1 408 555 5678'],
),
delta.Delete(
'facsimiletelephonenumber', ['+1 408 555 9876']),
]
)
result = sut.asLDIF()
self.assertEqual(b"""dn: cn=Paula Jensen,ou=Dev Ops,dc=airius,dc=com
changetype: modify
add: postaladdress
postaladdress: 123 Anystreet $ Sunnyvale, CA $ 94086
-
delete: description
-
replace: telephonenumber
telephonenumber: +1 408 555 1234
telephonenumber: +1 408 555 5678
-
delete: facsimiletelephonenumber
facsimiletelephonenumber: +1 408 555 9876
-
""",
result,
)
def testAsLDIF(self):
"""
It will return a LDIF representation of the contained operations.
"""
sut = delta.ModifyOp(
"cn=Paula Jensen, ou=Dev Ops, dc=airius, dc=com",
[
delta.Add(
"postaladdress",
["123 Anystreet $ Sunnyvale, CA $ 94086"],
),
delta.Delete("description"),
delta.Replace(
"telephonenumber",
["+1 408 555 1234", "+1 408 555 5678"],
),
delta.Delete("facsimiletelephonenumber", ["+1 408 555 9876"]),
],
)
result = sut.asLDIF()
self.assertEqual(
b"""dn: cn=Paula Jensen,ou=Dev Ops,dc=airius,dc=com
changetype: modify
add: postaladdress
postaladdress: 123 Anystreet $ Sunnyvale, CA $ 94086
-
delete: description
-
replace: telephonenumber
telephonenumber: +1 408 555 1234
telephonenumber: +1 408 555 5678
-
delete: facsimiletelephonenumber
facsimiletelephonenumber: +1 408 555 9876
-
""",
result,
)
def testAdd_Existing_OneType_ManyValues(self):
a = entry.BaseLDAPEntry(
dn="dc=foo",
attributes={
"foo": ["bar"],
},
)
b = entry.BaseLDAPEntry(
dn="dc=foo",
attributes={
"foo": ["bar", "quux", "thud", "foo"],
},
)
result = a.diff(b)
self.assertEqual(
result,
delta.ModifyOp(
"dc=foo",
[
delta.Add("foo", ["quux", "thud", "foo"]),
],
),
)
def testAdd_New_OneType_OneValue(self):
a = entry.BaseLDAPEntry(
dn="dc=foo",
attributes={
"foo": ["bar"],
},
)
b = entry.BaseLDAPEntry(
dn="dc=foo",
attributes={
"foo": ["bar"],
"baz": ["quux"],
},
)
result = a.diff(b)
self.assertEqual(
result,
delta.ModifyOp(
"dc=foo",
[
delta.Add("baz", ["quux"]),
],
),
)
def update(self, sequence):
self.ldapObject.journal(delta.Add(self.key, sequence))
super(JournaledLDAPAttributeSet, self).update(sequence)
def add(self, value):
self.ldapObject.journal(delta.Add(self.key, [value]))
super(JournaledLDAPAttributeSet, self).add(value)