from zope.schema.interfaces import IChoice from zope.schema.interfaces import IList from zope.schema import Choice from zope.schema import List from zope.schema.interfaces import IFromUnicode from plone.supermodel.exportimport import ChoiceHandler from plone.supermodel.exportimport import BaseHandler class IRadiobutton(IChoice): pass @implementer(IRadiobutton, IFromUnicode) class Radiobutton(Choice): pass class ICheckbox(IList): pass @implementer(ICheckbox, IFromUnicode) class Checkbox(List): pass # plone.supermodel export/import handler RadiobuttonHandler = ChoiceHandler(Radiobutton) CheckboxHandler = BaseHandler(Checkbox)
class TestChoiceHandling(unittest.TestCase): def setUp(self): configure() self.handler = ChoiceHandler(schema.Choice) def _choice(self): vocab = SimpleVocabulary( [SimpleTerm(t, title=t) for t in (u'a', u'b', u'c')] ) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element><element>b</element><element>c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_empty(self): # add an empty string term to vocabulary vocab = SimpleVocabulary([SimpleTerm(t, title=t) for t in (u'a', u'')]) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element>'\ '<element></element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_term_titles(self): # two terms with distinct titles, one with same as value: vocab = SimpleVocabulary( [SimpleTerm(t, title=t.upper()) for t in (u'a', u'b')] + [SimpleTerm(u'c', title=u'c')], ) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element key="a">A</element>'\ '<element key="b">B</element>'\ '<element key="c">c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def test_choice_serialized(self): field, expected = self._choice() el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) # now with an empty string term in vocab: field, expected = self._choice_with_empty() el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) # now with terms that have titles: field, expected = self._choice_with_term_titles() el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) def test_choice_parsing(self): _termvalues = lambda vocab: tuple((t.value, t.title) for t in vocab) cases = ( self._choice(), self._choice_with_empty(), self._choice_with_term_titles(), ) for field, expected in cases: el = etree.fromstring(expected) imported_field = self.handler.read(el) self.assertEquals( _termvalues(imported_field.vocabulary), _termvalues(field.vocabulary), )
def setUp(self): configure() self.handler = ChoiceHandler(schema.Choice)
class TestChoiceHandling(unittest.TestCase): def setUp(self): configure() self.handler = ChoiceHandler(schema.Choice) def _choice(self): vocab = SimpleVocabulary( [SimpleTerm(t, title=t) for t in (u'a', u'b', u'c')] ) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element><element>b</element><element>c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_empty(self): # add an empty string term to vocabulary vocab = SimpleVocabulary([SimpleTerm(t, title=t) for t in (u'a', u'')]) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element>'\ '<element></element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_term_titles(self): # two terms with distinct titles, one with same as value: vocab = SimpleVocabulary( [SimpleTerm(t, title=t.upper()) for t in (u'a', u'b')] + [SimpleTerm(u'c', title=u'c')], ) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element key="a">A</element>'\ '<element key="b">B</element>'\ '<element key="c">c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_term_titles_and_ns(self): # two terms with distinct titles, one with same as value: vocab = SimpleVocabulary( [SimpleTerm(t, title=t.upper()) for t in (u'a', u'b')] + [SimpleTerm(u'c', title=u'c')], ) expected = '<field name="myfield" type="zope.schema.Choice"'\ ' xmlns="http://namespaces.plone.org/supermodel/schema">'\ '<values>'\ '<element key="a">A</element>'\ '<element key="b">B</element>'\ '<element key="c">c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def test_choice_serialized(self): """ Tests a regular choice, one with empty string term in vocab, and another with terms that have titles """ choice = self._choice() choice_with_empty = self._choice_with_empty() choice_with_term_titles = self._choice_with_term_titles() for case in (choice, choice_with_empty, choice_with_term_titles): field, expected = case expected = six.binary_type(expected) if six.PY2 \ else six.binary_type(expected, encoding='latin-1') el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) def test_choice_parsing(self): def _termvalues(vocab): return tuple((t.value, t.title) for t in vocab) cases = ( self._choice(), self._choice_with_empty(), self._choice_with_term_titles(), self._choice_with_term_titles_and_ns(), ) for field, expected in cases: el = etree.fromstring(expected) imported_field = self.handler.read(el) self.assertEqual( _termvalues(imported_field.vocabulary), _termvalues(field.vocabulary), )
class TestChoiceHandling(unittest.TestCase): def setUp(self): configure() self.handler = ChoiceHandler(schema.Choice) def _choice(self): vocab = SimpleVocabulary( [SimpleTerm(t, title=t) for t in (u'a', u'b', u'c')]) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element><element>b</element><element>c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_empty(self): # add an empty string term to vocabulary vocab = SimpleVocabulary([SimpleTerm(t, title=t) for t in (u'a', u'')]) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element>'\ '<element></element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_term_titles(self): # two terms with distinct titles, one with same as value: vocab = SimpleVocabulary( [SimpleTerm(t, title=t.upper()) for t in (u'a', u'b')] + [SimpleTerm(u'c', title=u'c')], ) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element key="a">A</element>'\ '<element key="b">B</element>'\ '<element key="c">c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_term_titles_and_ns(self): # two terms with distinct titles, one with same as value: vocab = SimpleVocabulary( [SimpleTerm(t, title=t.upper()) for t in (u'a', u'b')] + [SimpleTerm(u'c', title=u'c')], ) expected = '<field name="myfield" type="zope.schema.Choice"'\ ' xmlns="http://namespaces.plone.org/supermodel/schema">'\ '<values>'\ '<element key="a">A</element>'\ '<element key="b">B</element>'\ '<element key="c">c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_integers(self): vocab = SimpleVocabulary([SimpleTerm(1, title=u'One')]) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element key="1">One</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def test_choice_serialized(self): """ Tests a regular choice, one with empty string term in vocab, and another with terms that have titles """ choice = self._choice() choice_with_empty = self._choice_with_empty() choice_with_term_titles = self._choice_with_term_titles() choice_with_integers = self._choice_with_integers() for case in (choice, choice_with_empty, choice_with_term_titles, choice_with_integers): field, expected = case expected = six.binary_type(expected) if six.PY2 \ else six.binary_type(expected, encoding='latin-1') el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) def test_choice_parsing(self): def _termvalues(vocab): return tuple((t.value, t.title) for t in vocab) cases = ( self._choice(), self._choice_with_empty(), self._choice_with_term_titles(), self._choice_with_term_titles_and_ns(), ) for field, expected in cases: el = etree.fromstring(expected) imported_field = self.handler.read(el) self.assertEqual( _termvalues(imported_field.vocabulary), _termvalues(field.vocabulary), )
class TestChoiceHandling(unittest.TestCase): def setUp(self): configure() self.handler = ChoiceHandler(schema.Choice) def _choice(self): vocab = SimpleVocabulary( [SimpleTerm(t, title=t) for t in (u'a', u'b', u'c')]) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element><element>b</element><element>c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_empty(self): # add an empty string term to vocabulary vocab = SimpleVocabulary([SimpleTerm(t, title=t) for t in (u'a', u'')]) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element>a</element>'\ '<element></element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def _choice_with_term_titles(self): # two terms with distinct titles, one with same as value: vocab = SimpleVocabulary( [SimpleTerm(t, title=t.upper()) for t in (u'a', u'b')] + [SimpleTerm(u'c', title=u'c')], ) expected = '<field name="myfield" type="zope.schema.Choice">'\ '<values>'\ '<element key="a">A</element>'\ '<element key="b">B</element>'\ '<element key="c">c</element>'\ '</values>'\ '</field>' return (schema.Choice(vocabulary=vocab), expected) def test_choice_serialized(self): field, expected = self._choice() el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) # now with an empty string term in vocab: field, expected = self._choice_with_empty() el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) # now with terms that have titles: field, expected = self._choice_with_term_titles() el = self.handler.write(field, 'myfield', 'zope.schema.Choice') self.assertEquals(etree.tostring(el), expected) def test_choice_parsing(self): _termvalues = lambda vocab: tuple((t.value, t.title) for t in vocab) cases = ( self._choice(), self._choice_with_empty(), self._choice_with_term_titles(), ) for field, expected in cases: el = etree.fromstring(expected) imported_field = self.handler.read(el) self.assertEquals( _termvalues(imported_field.vocabulary), _termvalues(field.vocabulary), )
rel_list = None if not rel_list: return [] resolved_list = [] for rel in rel_list: if rel.isBroken(): # XXX: should log or take action here continue resolved_list.append(rel.to_object) return resolved_list def set(self, value): """Sets the relationship target""" value = value or [] new_relationships = [] intids = getUtility(IIntIds) for item in value: # otherwise create one to_id = intids.getId(item) new_relationships.append(RelationValue(to_id)) super(RelationListDataManager, self).set(new_relationships) # plone.supermodel schema import/export handlers RelationChoiceHandler = ChoiceHandler(RelationChoice) RelationListHandler = BaseHandler(RelationList)