def testCorrectValueType(self):
# TODO: We should not allow for a None value type.
FrozenSet(value_type=None)
# do not allow arbitrary value types
self.assertRaises(ValueError, FrozenSet, value_type=object())
self.assertRaises(ValueError, FrozenSet, value_type=Field)
# however, allow anything that implements IField
FrozenSet(value_type=Field())
class FakeField(object):
implements(IField)
FrozenSet(value_type=FakeField())
class ISiteTemplate(Interface):
""" describes the template for creating a site
"""
id = TextLine(title=u'Template ID',
description=u'ID must be a valid python identifier',
required=True)
name = TextLine(title=u'Template Name', required=True)
description = Text(
title=u"Template Description",
description=u"The description of this template shown to users",
required=True)
price = Decimal(
title=u"Template Price",
description=
u"The price users will be charged per subscription period for a site built from this template",
required=True)
products = FrozenSet(
title=u"Installed Products",
description=
u"Choose the products to install when creating a site from this template",
required=True,
value_type=Choice(vocabulary=SimpleVocabulary((
SimpleTerm(token='Foo', value='foo'),
SimpleTerm(token='Bar', value='bar'),
SimpleTerm(token='Baz', value='baz'),
)), ),
default=frozenset([
'foo',
]))
def testValidateRequired(self):
field = FrozenSet(title=u'Set field',
description=u'',
readonly=False,
required=True)
field.validate(frozenset())
field.validate(frozenset((1, 2)))
field.validate(frozenset((3, )))
self.assertRaises(RequiredMissing, field.validate, None)
def testValidateMaxValues(self):
field = FrozenSet(title=u'FrozenSet field',
description=u'',
readonly=False,
required=False,
max_length=2)
field.validate(None)
field.validate(frozenset())
field.validate(frozenset((1, 2)))
self.assertRaises(TooLong, field.validate, frozenset((1, 2, 3, 4)))
self.assertRaises(TooLong, field.validate, frozenset((1, 2, 3)))
def testValidateMinValues(self):
field = FrozenSet(title=u'FrozenSet field',
description=u'',
readonly=False,
required=False,
min_length=2)
field.validate(None)
field.validate(frozenset((1, 2)))
field.validate(frozenset((1, 2, 3)))
self.assertRaises(TooShort, field.validate, frozenset(()))
self.assertRaises(TooShort, field.validate, frozenset((3, )))
def testValidateValueTypes(self):
field = FrozenSet(title=u'FrozenSet field',
description=u'',
readonly=False,
required=False,
value_type=Int())
field.validate(None)
field.validate(frozenset((5, )))
field.validate(frozenset((2, 3)))
self.assertRaises(WrongContainedType, field.validate, frozenset(
('', )))
self.assertRaises(WrongContainedType, field.validate,
frozenset((3.14159, )))
def testValidate(self):
field = FrozenSet(title=u'Set field',
description=u'',
readonly=False,
required=False)
field.validate(None)
field.validate(frozenset())
field.validate(frozenset((1, 2)))
field.validate(frozenset((3, )))
self.assertRaises(WrongType, field.validate, [1, 2, 3])
self.assertRaises(WrongType, field.validate, 'abc')
self.assertRaises(WrongType, field.validate, 1)
self.assertRaises(WrongType, field.validate, {})
self.assertRaises(WrongType, field.validate, (1, 2, 3))
self.assertRaises(WrongType, field.validate, set((1, 2, 3)))
self.assertRaises(WrongType, field.validate, set((1, 2, 3)))
class IListUsersForm(Interface):
"""Field definition for List Users form."""
groups = FrozenSet(
title=_(u'Groups'),
description=_(u'Select groups from which you want to display users ' \
'from.'),
constraint=must_select_one_constraint,
value_type=Choice(
vocabulary='plone.app.vocabularies.Groups',
)
)
user_attributes = List(
title=_(u'User attributes'),
description=_(u'Select which user attributes you want displayed in ' \
'the results table.'),
constraint=must_select_one_constraint,
value_type=Choice(
vocabulary='collective.listusers.vocabularies.UserAttributes',
)
)
class ICollector(Interface):
choice = Choice(
title=u"Number",
description=u"The Number",
# we want to be able to distinguish between tokens and values
vocabulary=vocab,
required=True)
numbers = List(title=u"Numbers",
description=u"The Numbers",
value_type=choice,
required=False)
letters = Set(title=u"Letters",
description=u"The Letters",
value_type=choice,
required=False)
frozenLetters = FrozenSet(title=u"Frozen Letters",
description=u"The Frozen Letters",
value_type=choice,
required=False)
class IGitRuleGrantEditableAttributes(Interface):
"""`IGitRuleGrant` attributes that can be edited.
These attributes need launchpad.View to see, and launchpad.Edit to change.
"""
can_create = Bool(
title=_("Can create"), required=True, readonly=False,
description=_("Whether creating references is allowed."))
can_push = Bool(
title=_("Can push"), required=True, readonly=False,
description=_("Whether pushing references is allowed."))
can_force_push = Bool(
title=_("Can force-push"), required=True, readonly=False,
description=_("Whether force-pushing references is allowed."))
permissions = FrozenSet(
title=_("Permissions"), required=True, readonly=False,
value_type=Choice(vocabulary=GitPermissionType),
description=_("The permissions granted by this grant."))
class IBugSubscriptionFilterAttributes(Interface):
"""Attributes of `IBugSubscriptionFilter`."""
id = Int(required=True, readonly=True)
structural_subscription = exported(
Reference(
IStructuralSubscription,
title=_("Structural subscription"),
required=True, readonly=True))
find_all_tags = exported(
Bool(
title=_("Find all tags"),
description=_(
"If enabled, all tags must match, "
"else at least one tag must match."),
required=True, default=False))
include_any_tags = Bool(
title=_("Include any tags"),
required=True, default=False)
exclude_any_tags = Bool(
title=_("Exclude all tags"),
required=True, default=False)
bug_notification_level = exported(
Choice(
title=_("Bug notification level"), required=True,
vocabulary=BugNotificationLevel,
default=BugNotificationLevel.COMMENTS,
description=_("The volume and type of bug notifications "
"this subscription will generate.")))
description = exported(
Text(
title=_("A short description of this filter"),
required=False))
statuses = exported(
FrozenSet(
title=_("The statuses interested in (empty for all)"),
required=True, default=frozenset(),
value_type=Choice(
title=_('Status'), vocabulary=BugTaskStatus)))
importances = exported(
FrozenSet(
title=_("The importances interested in (empty for all)"),
required=True, default=frozenset(),
value_type=Choice(
title=_('Importance'), vocabulary=BugTaskImportance)))
tags = exported(
FrozenSet(
title=_("The tags interested in"),
required=True, default=frozenset(),
value_type=SearchTag()))
information_types = exported(
FrozenSet(
title=_("The information types interested in (empty for all)"),
required=True, default=frozenset(),
value_type=Choice(
title=_('Information type'), vocabulary=InformationType)))
def testValidateDefaultAltMissingValue(self):
missing = object()
field = FrozenSet(required=True, missing_value=missing)
field.default = missing
def testImplements(self):
field = FrozenSet()
self.failUnless(IFrozenSet.providedBy(field))
self.failUnless(IAbstractSet.providedBy(field))
self.failUnless(IUnorderedCollection.providedBy(field))
self.failUnless(ICollection.providedBy(field))
def testNoUniqueArgument(self):
self.assertRaises(TypeError, FrozenSet, unique=False)
self.assertRaises(TypeError, FrozenSet, unique=True)
self.failUnless(FrozenSet().unique)
def testImplements(self):
field = FrozenSet()
self.assertTrue(IFrozenSet.providedBy(field))
self.assertTrue(IAbstractSet.providedBy(field))
self.assertTrue(IUnorderedCollection.providedBy(field))
self.assertTrue(ICollection.providedBy(field))
def testValidateRequiredAltMissingValue(self):
missing = object()
field = FrozenSet(required=True, missing_value=missing)
field.validate(frozenset())
self.assertRaises(RequiredMissing, field.validate, missing)
def testValidateDefault(self):
field = FrozenSet(required=True)
field.default = None