Attachment #8364 for bug #43395

View | Details | Raw Unified | Return to bug 43395
Collapse All | Expand All





	def default(self, object):
		if not object.set_defaults:
			return [] if self.multivalue else ''
				return []
			else:
				return ''

		if not self.base_default:
			return self.new()

		if isinstance(self.base_default, basestring):
			return self._replace(self.base_default, object)

		bd0 = self.base_default[0]

		# we can not import univention.admin.syntax here (recursive import) so we need to find another way to identify a complex syntax
		if getattr(self.syntax, 'subsyntaxes', None) is not None and isinstance(bd0, (list, tuple)) and not self.multivalue:
			return bd0

		if isinstance(bd0, basestring):
			# multivalue defaults will only be a part of templates, so not multivalue is the common way for modules
			if not self.multivalue:  # default=(template-str, [list-of-required-properties])
				if all(object[p] for p in self.base_default[1]):
					for p in self.base_default[1]:
						bd0 = bd0.replace('<%s>' % (p,), object[p])
					return bd0
				return self.new()
			else:  # multivalue
				if all(isinstance(bd, basestring) for bd in self.base_default):
					return [self._replace(bd, object) for bd in self.base_default]
				# must be a list of loaded extended attributes then, so we return it if it has content
				# return the first element, this is only related to empty extended attributes which are loaded wrong, needs to be fixed elsewhere
				if bd0:
					return [bd0]
				return self.new()

		if callable(bd0):  # default=(func_obj_extra, [list-of-required-properties], extra-arg)
			if all(object[p] for p in self.base_default[1]):
				return bd0(object, self.base_default[2])
						if i > 0:
							if self.multivalue and not isinstance(self.base_default[0], types.ListType):
								return [self.base_default[0]]
							else:
								return self.base_default[0]
						else:
							return self.new()
			return self.base_default

		elif isinstance(self.base_default[0], types.FunctionType) or callable(self.base_default[0]):
			for p in self.base_default[1]:
				if not object[p]:
					return self.new()
			return self.base_default[0](object, self.base_default[2])
		else:
			return self.new()

		return self.new()

	def safe_default(self, object):
		def safe_parse(default):
			if not default:

			except:
				return False
		defaults = self.default(object)
		if isinstance(defaults, list):
			return [self.syntax.parse(d) for d in defaults if safe_parse(d)]
		elif safe_parse(defaults):
			return self.syntax.parse(defaults)

	def check_default(self, object):
		defaults = self.default(object)
		try:
			if isinstance(defaults, list):
				for d in defaults:
					if d:
						self.syntax.parse(d)




#!/usr/bin/python

from univention.admin import property
import unittest
from argparse import Namespace as N


class FakeObject(dict):
	set_defaults = True


class TestProperty(unittest.TestCase):

	def test_default_sv(self):
		p = property()
		o = N(set_defaults=False)
		self.assertEqual(p.default(o), '')

	def test_default_mv(self):
		p = property(multivalue=True)
		o = N(set_defaults=False)
		self.assertEqual(p.default(o), [])

	def test_base_default_sv(self):
		p = property()
		o = FakeObject()
		self.assertIsNone(p.default(o))

	def test_base_default_mv(self):
		p = property(multivalue=True)
		o = FakeObject()
		self.assertEqual(p.default(o), [])

	def test_str_default_sv(self):
		p = property(default='x')
		o = FakeObject()
		self.assertEqual(p.default(o), 'x')

	# def test_str_default_mv(self):
	# 	p = property(multivalue=True, default=('x', 'y'))
	# 	o = N(set_defaults=True)
	# 	self.assertEqual(p.default(o), ['x', 'y'])

	def test_complex_syntax(self):
		s = N(subsyntaxes=())
		p = property(multivalue=False, default=(('x', 'y'),), syntax=s)
		o = FakeObject()
		self.assertEqual(p.default(o), ('x', 'y'))

	def test_template_sv_empty(self):
		p = property(multivalue=False, default=('templ', ['prop']))
		o = FakeObject(prop='')
		self.assertIsNone(p.default(o))

	def test_template_sv_set(self):
		p = property(multivalue=False, default=('<prop>', ['prop']))
		o = FakeObject(prop='value')
		self.assertEqual(p.default(o), 'value')

	def test_template_mv_set(self):
		p = property(multivalue=True, default=('<prop1>', '<prop2>'))
		o = FakeObject(prop1='value1', prop2='value2')
		self.assertEqual(p.default(o), ['value1', 'value2'])

	def test_template_mv_incomplete(self):
		p = property(multivalue=True, default=('<prop>', None))
		o = FakeObject()
		self.assertEqual(p.default(o), ['<prop>'])

	def test_template_mv_empty(self):
		p = property(multivalue=True, default=('', None))
		o = FakeObject()
		self.assertEqual(p.default(o), [])

	def test_callable_set(self):
		x = object()
		o = FakeObject(prop='value1')
		f = lambda obj, extra: 'value2' if extra is x and obj is o else 'error'
		p = property(multivalue=False, default=(f, ['prop'], x))
		self.assertEqual(p.default(o), 'value2')

	def test_callable_empty_sv(self):
		x = object()
		o = FakeObject(prop='')
		f = lambda obj, extra: 1 / 0
		p = property(multivalue=False, default=(f, ['prop'], x))
		self.assertIsNone(p.default(o))

	def test_callable_empty_mv(self):
		x = object()
		o = FakeObject(prop='')
		f = lambda obj, extra: 1 / 0
		p = property(multivalue=True, default=(f, ['prop'], x))
		self.assertEqual(p.default(o), [])

	def test_fallback_sv(self):
		o = FakeObject()
		p = property(multivalue=False, default=(None,))
		self.assertIsNone(p.default(o))

	def test_fallback_mv(self):
		o = FakeObject()
		p = property(multivalue=True, default=(None,))
		self.assertEqual(p.default(o), [])


if __name__ == '__main__':
	unittest.main()

Return to bug 43395

Lines 240-297 class property: Link Here

(-)a/management/univention-directory-manager-modules/modules/univention/admin/__init__.py (-45 / +31 lines)
240		240
241	def default(self, object):	241	def default(self, object):
242	if not object.set_defaults:	242	if not object.set_defaults:
243	if self.multivalue:	243	return [] if self.multivalue else ''
244	return []
245	else:
246	return ''
247		244
248	if not self.base_default:	245	if not self.base_default:
249	return self.new()	246	return self.new()
250		247
251	if isinstance(self.base_default, (types.StringType, types.UnicodeType)):	248	if isinstance(self.base_default, basestring):
252	return self._replace(self.base_default, object)	249	return self._replace(self.base_default, object)
253		250
		251	bd0 = self.base_default[0]
		252
254	# we can not import univention.admin.syntax here (recursive import) so we need to find another way to identify a complex syntax	253	# we can not import univention.admin.syntax here (recursive import) so we need to find another way to identify a complex syntax
255	if getattr(self.syntax, 'subsyntaxes', None) is not None and isinstance(self.base_default[0], (list, tuple)) and not self.multivalue:	254	if getattr(self.syntax, 'subsyntaxes', None) is not None and isinstance(bd0, (list, tuple)) and not self.multivalue:
256	return self.base_default[0]	255	return bd0
257	# multivalue defaults will only be a part of templates, so not multivalue is the common way for modules	256
258	elif (isinstance(self.base_default[0], (types.StringType, types.UnicodeType))) and not self.multivalue:	257	if isinstance(bd0, basestring):
259	res = self.base_default[0]	258	# multivalue defaults will only be a part of templates, so not multivalue is the common way for modules
260	for p in self.base_default[1]:	259	if not self.multivalue: # default=(template-str, [list-of-required-properties])
261	if not object[p]:	260	if all(object[p] for p in self.base_default[1]):
262	return self.new()	261	for p in self.base_default[1]:
263	res = res.replace('<' + p + '>', object[p])	262	bd0 = bd0.replace('<%s>' % (p,), object[p])
264	return res	263	return bd0
265		264	return self.new()
266	elif (isinstance(self.base_default[0], (types.StringType, types.UnicodeType))):	265	else: # multivalue
267	for i in range(0, len(self.base_default)):	266	if all(isinstance(bd, basestring) for bd in self.base_default):
268	if isinstance(self.base_default[i], (types.StringType, types.UnicodeType)):	267	return [self._replace(bd, object) for bd in self.base_default]
269	self.base_default[i] = self._replace(self.base_default[i], object)	268	# must be a list of loaded extended attributes then, so we return it if it has content
270	else: # must be a list of loaded extended attributes then, so we return it if it has content	269	# return the first element, this is only related to empty extended attributes which are loaded wrong, needs to be fixed elsewhere
271	if len(self.base_default[i]) > 0:	270	if bd0:
272	if self.multivalue and not isinstance(self.base_default[i], types.ListType):	271	return [bd0]
273	return [self.base_default[i]]	272	return self.new()
274	else:	273
275	return self.base_default[i]	274	if callable(bd0): # default=(func_obj_extra, [list-of-required-properties], extra-arg)
276	else:	275	if all(object[p] for p in self.base_default[1]):
277	# return the first element, this is only related to empty extended attributes which are loaded wrong, needs to be fixed elsewhere	276	return bd0(object, self.base_default[2])
278	if i > 0:
279	if self.multivalue and not isinstance(self.base_default[0], types.ListType):
280	return [self.base_default[0]]
281	else:
282	return self.base_default[0]
283	else:
284	return self.new()
285	return self.base_default
286
287	elif isinstance(self.base_default[0], types.FunctionType) or callable(self.base_default[0]):
288	for p in self.base_default[1]:
289	if not object[p]:
290	return self.new()
291	return self.base_default[0](object, self.base_default[2])
292	else:
293	return self.new()	277	return self.new()
294		278
		279	return self.new()
		280
295	def safe_default(self, object):	281	def safe_default(self, object):
296	def safe_parse(default):	282	def safe_parse(default):
297	if not default:	283	if not default:
Lines 302-308 class property: Link Here
302	except:	288	except:
303	return False	289	return False
304	defaults = self.default(object)	290	defaults = self.default(object)
305	if isinstance(defaults, types.ListType):	291	if isinstance(defaults, list):
306	return [self.syntax.parse(d) for d in defaults if safe_parse(d)]	292	return [self.syntax.parse(d) for d in defaults if safe_parse(d)]
307	elif safe_parse(defaults):	293	elif safe_parse(defaults):
308	return self.syntax.parse(defaults)	294	return self.syntax.parse(defaults)
Lines 311-317 class property: Link Here
311	def check_default(self, object):	297	def check_default(self, object):
312	defaults = self.default(object)	298	defaults = self.default(object)
313	try:	299	try:
314	if isinstance(defaults, types.ListType):	300	if isinstance(defaults, list):
315	for d in defaults:	301	for d in defaults:
316	if d:	302	if d:
317	self.syntax.parse(d)	303	self.syntax.parse(d)

Line 0 Link Here

(-)a/management/univention-directory-manager-modules/test/test-univention-admin.py (-1 / +108 lines)
0	-	1	#!/usr/bin/python
		2
		3	from univention.admin import property
		4	import unittest
		5	from argparse import Namespace as N
		6
		7
		8	class FakeObject(dict):
		9	set_defaults = True
		10
		11
		12	class TestProperty(unittest.TestCase):
		13
		14	def test_default_sv(self):
		15	p = property()
		16	o = N(set_defaults=False)
		17	self.assertEqual(p.default(o), '')
		18
		19	def test_default_mv(self):
		20	p = property(multivalue=True)
		21	o = N(set_defaults=False)
		22	self.assertEqual(p.default(o), [])
		23
		24	def test_base_default_sv(self):
		25	p = property()
		26	o = FakeObject()
		27	self.assertIsNone(p.default(o))
		28
		29	def test_base_default_mv(self):
		30	p = property(multivalue=True)
		31	o = FakeObject()
		32	self.assertEqual(p.default(o), [])
		33
		34	def test_str_default_sv(self):
		35	p = property(default='x')
		36	o = FakeObject()
		37	self.assertEqual(p.default(o), 'x')
		38
		39	# def test_str_default_mv(self):
		40	# p = property(multivalue=True, default=('x', 'y'))
		41	# o = N(set_defaults=True)
		42	# self.assertEqual(p.default(o), ['x', 'y'])
		43
		44	def test_complex_syntax(self):
		45	s = N(subsyntaxes=())
		46	p = property(multivalue=False, default=(('x', 'y'),), syntax=s)
		47	o = FakeObject()
		48	self.assertEqual(p.default(o), ('x', 'y'))
		49
		50	def test_template_sv_empty(self):
		51	p = property(multivalue=False, default=('templ', ['prop']))
		52	o = FakeObject(prop='')
		53	self.assertIsNone(p.default(o))
		54
		55	def test_template_sv_set(self):
		56	p = property(multivalue=False, default=('<prop>', ['prop']))
		57	o = FakeObject(prop='value')
		58	self.assertEqual(p.default(o), 'value')
		59
		60	def test_template_mv_set(self):
		61	p = property(multivalue=True, default=('<prop1>', '<prop2>'))
		62	o = FakeObject(prop1='value1', prop2='value2')
		63	self.assertEqual(p.default(o), ['value1', 'value2'])
		64
		65	def test_template_mv_incomplete(self):
66	p = property(multivalue=True, default=('<prop>', None))
67	o = FakeObject()
68	self.assertEqual(p.default(o), ['<prop>'])
69
70	def test_template_mv_empty(self):
71	p = property(multivalue=True, default=('', None))
72	o = FakeObject()
73	self.assertEqual(p.default(o), [])
74
75	def test_callable_set(self):
76	x = object()
77	o = FakeObject(prop='value1')
78	f = lambda obj, extra: 'value2' if extra is x and obj is o else 'error'
79	p = property(multivalue=False, default=(f, ['prop'], x))
80	self.assertEqual(p.default(o), 'value2')
81
82	def test_callable_empty_sv(self):
83	x = object()
84	o = FakeObject(prop='')
85	f = lambda obj, extra: 1 / 0
86	p = property(multivalue=False, default=(f, ['prop'], x))
87	self.assertIsNone(p.default(o))
88
89	def test_callable_empty_mv(self):
90	x = object()
91	o = FakeObject(prop='')
92	f = lambda obj, extra: 1 / 0
93	p = property(multivalue=True, default=(f, ['prop'], x))
94	self.assertEqual(p.default(o), [])
95
96	def test_fallback_sv(self):
97	o = FakeObject()
98	p = property(multivalue=False, default=(None,))
99	self.assertIsNone(p.default(o))
100
101	def test_fallback_mv(self):
102	o = FakeObject()
103	p = property(multivalue=True, default=(None,))
104	self.assertEqual(p.default(o), [])
105
106
107	if __name__ == '__main__':
108	unittest.main()