Ejemplo n.º 1
0
    def cleanupLayers(self, instance, item=None, container=None):
        # scan each field looking for registered layers optionally
        # call its cleanupInstance method and then the cleanupField
        # method
        queuedLayers = []
        queued = lambda x: x in queuedLayers

        for field in self.fields():
            if ILayerContainer.providedBy(field):
                layers = field.registeredLayers()
                for layer, obj in layers:
                    if not queued((layer, obj)):
                        queuedLayers.append((layer, obj))
                    if ILayer.providedBy(obj):
                        obj.cleanupField(instance, field)

        for layer, obj in queuedLayers:
            if ILayer.providedBy(obj):
                obj.cleanupInstance(instance, item, container)

        # Now do the same for objects registered at this level

        if ILayerContainer.providedBy(self):
            for layer, obj in self.registeredLayers():
                if (not queued((layer, obj)) and
                        ILayer.providedBy(obj)):
                    obj.cleanupInstance(instance, item, container)
                    queuedLayers.append((layer, obj))
 def test_facultyReviewerField(self):
     pro = self.createProosal()
     self.fill_out_proposal(pro)
     field = pro.getField('facultyReviewer')
     self.failUnless(ILayerContainer.isImplementedBy(field))
     self.failUnless(field.required == 0, 'Value is %s' % field.required)
     #self.failUnless(field.default == (), 'Value is %s' % str(str(field.default)))
     self.failUnless(field.searchable == 0, 'Value is %s' % field.searchable)
     self.failUnless(field.enforceVocabulary == 0,
                     'Value is %s' % field.enforceVocabulary)
     self.failUnless(field.multiValued == 0,
                     'Value is %s' % field.multiValued)
     self.failUnless(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
     self.failUnless(field.accessor == 'getFacultyReviewer',
                     'Value is %s' % field.accessor)
     self.failUnless(field.mutator == 'setFacultyReviewer',
                     'Value is %s' % field.mutator)
     self.failUnless(field.read_permission == 'View',
                     'Value is %s' % field.read_permission)
     self.failUnless(field.write_permission ==
                     'uwosh_grants: Set reviewer permission',
                     'Value is %s' % field.write_permission)
     self.failUnless(field.generateMode == 'veVc',
                     'Value is %s' % field.generateMode)
     self.failUnless(field.force == '', 'Value is %s' % field.force)
     self.failUnless(field.type == 'string', 'Value is %s' % field.type)
     self.failUnless(isinstance(field.storage, AttributeStorage),
                     'Value is %s' % type(field.storage))
     self.failUnless(field.getLayerImpl('storage') == AttributeStorage(),
                     'Value is %s' % field.getLayerImpl('storage'))
     self.failUnless(ILayerContainer.isImplementedBy(field))
     self.failUnless(field.validators == EmptyValidator,
                     'Value is %s' % repr(field.validators))
     self.failUnless(isinstance(field.widget, MultiSelectionWidget),
                     'Value is %s' % id(field.widget))
Ejemplo n.º 3
0
    def test_id(self):
        dummy = self._dummy
        field = dummy.getField('id')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0)
        self.assertTrue(field.default == None)
        self.assertTrue(field.searchable == 0)
        self.assertTrue(field.vocabulary == ())
        self.assertTrue(field.enforceVocabulary == 0)
        self.assertTrue(field.multiValued == 0)
        self.assertTrue(field.isMetadata == 0)
        self.assertTrue(field.accessor == 'getId')
        self.assertTrue(field.mutator == 'setId')
        self.assertTrue(field.read_permission == permissions.View)
        self.assertTrue(field.write_permission ==
                        permissions.ModifyPortalContent)
        self.assertTrue(field.generateMode == 'veVc')
        self.assertTrue(field.force == '')
        self.assertTrue(field.type == 'string')
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage))
        self.assertTrue(field.getLayerImpl('storage') == atapi.AttributeStorage())
        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.validators == EmptyValidator)
        self.assertTrue(isinstance(field.widget, atapi.IdWidget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList))
        self.assertTrue(tuple(vocab) == ())
Ejemplo n.º 4
0
    def test_textField(self):
        dummy = self._dummy
        field = dummy.getField("text")

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0, "Value is %s" % field.required)
        self.assertTrue(field.default == "", "Value is %s" % str(field.default))
        self.assertTrue(field.searchable == 1, "Value is %s" % field.searchable)
        self.assertTrue(field.vocabulary == (), "Value is %s" % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0, "Value is %s" % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0, "Value is %s" % field.multiValued)
        self.assertTrue(field.isMetadata == 0, "Value is %s" % field.isMetadata)
        self.assertTrue(field.accessor == "getText", "Value is %s" % field.accessor)
        self.assertTrue(field.mutator == "setText", "Value is %s" % field.mutator)
        self.assertTrue(field.read_permission == View, "Value is %s" % field.read_permission)
        self.assertTrue(field.write_permission == ModifyPortalContent, "Value is %s" % field.write_permission)
        self.assertTrue(field.generateMode == "veVc", "Value is %s" % field.generateMode)
        self.assertTrue(field.force == "", "Value is %s" % field.force)
        self.assertTrue(field.type == "text", "Value is %s" % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AnnotationStorage), "Value is %s" % type(field.storage))
        self.assertTrue(
            field.getLayerImpl("storage") == atapi.AnnotationStorage(migrate=True),
            "Value is %s" % field.getLayerImpl("storage"),
        )
        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.validators == NotRequiredTidyHTMLValidator, "Value is %s" % repr(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.TinyMCEWidget), "Value is %s" % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList), "Value is %s" % type(vocab))
        self.assertTrue(tuple(vocab) == (), "Value is %s" % str(tuple(vocab)))

        self.assertTrue(field.primary == 1, "Value is %s" % field.primary)
        self.assertTrue(field.default_content_type is None, "Value is %s" % field.default_content_type)
        self.assertTrue(field.default_output_type == "text/x-html-safe", "Value is %s" % field.default_output_type)
        self.assertTrue("text/html" in field.getAllowedContentTypes(dummy))
Ejemplo n.º 5
0
 def test_subjectField(self):
     dummy = self._dummy
     field = dummy.getField('subject')
     self.assertTrue(ILayerContainer.providedBy(field))
     self.assertTrue(field.required == 0, 'Value is %s' % field.required)
     self.assertTrue(field.default == (), 'Value is %s' % str(str(field.default)))
     self.assertTrue(field.searchable == 1, 'Value is %s' % field.searchable)
     self.assertTrue(field.enforceVocabulary == 0,
                     'Value is %s' % field.enforceVocabulary)
     self.assertTrue(field.multiValued == 1,
                     'Value is %s' % field.multiValued)
     self.assertTrue(field.isMetadata == 1, 'Value is %s' % field.isMetadata)
     self.assertTrue(field.accessor == 'Subject',
                     'Value is %s' % field.accessor)
     self.assertTrue(field.mutator == 'setSubject',
                     'Value is %s' % field.mutator)
     self.assertTrue(field.read_permission == View,
                     'Value is %s' % field.read_permission)
     self.assertTrue(field.write_permission ==
                     ModifyPortalContent,
                     'Value is %s' % field.write_permission)
     self.assertTrue(field.generateMode == 'mVc',
                     'Value is %s' % field.generateMode)
     self.assertTrue(field.force == '', 'Value is %s' % field.force)
     self.assertTrue(field.type == 'lines', 'Value is %s' % field.type)
     self.assertTrue(isinstance(field.storage, atapi.MetadataStorage),
                     'Value is %s' % type(field.storage))
     self.assertTrue(field.getLayerImpl('storage') == atapi.MetadataStorage(),
                     'Value is %s' % field.getLayerImpl('storage'))
     self.assertTrue(ILayerContainer.providedBy(field))
     self.assertTrue(field.validators == EmptyValidator,
                     'Value is %s' % repr(field.validators))
     self.assertTrue(isinstance(field.widget, atapi.TagsWidget),
                     'Value is %s' % id(field.widget))
Ejemplo n.º 6
0
    def test_remoteUrlField(self):
        dummy = self._dummy
        field = dummy.getField("remoteUrl")

        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.required == 1, "Value is %s" % field.required)
        self.failUnless(field.default == "", "Value is %s" % str(field.default))
        self.failUnless(field.searchable == 1, "Value is %s" % field.searchable)
        self.failUnless(field.vocabulary == (), "Value is %s" % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0, "Value is %s" % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0, "Value is %s" % field.multiValued)
        self.failUnless(field.isMetadata == 0, "Value is %s" % field.isMetadata)
        self.failUnless(field.accessor == "_getRemoteUrl", "Value is %s" % field.accessor)
        self.failUnless(field.mutator == "setRemoteUrl", "Value is %s" % field.mutator)
        self.failUnless(field.read_permission == View, "Value is %s" % field.read_permission)
        self.failUnless(field.write_permission == ModifyPortalContent, "Value is %s" % field.write_permission)
        self.failUnless(field.generateMode == "veVc", "Value is %s" % field.generateMode)
        self.failUnless(field.force == "", "Value is %s" % field.force)
        self.failUnless(field.type == "string", "Value is %s" % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage), "Value is %s" % type(field.storage))
        self.failUnless(
            field.getLayerImpl("storage") == AttributeStorage(), "Value is %s" % field.getLayerImpl("storage")
        )
        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.validators == (), "Value is %s" % str(field.validators))
        self.failUnless(isinstance(field.widget, StringWidget), "Value is %s" % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList), "Value is %s" % type(vocab))
        self.failUnless(tuple(vocab) == (), "Value is %s" % str(tuple(vocab)))
        self.failUnless(field.primary == 1, "Value is %s" % field.primary)
Ejemplo n.º 7
0
 def test_eventTypeField(self):
     dummy = self._dummy
     field = dummy.getField('eventType')
     self.failUnless(ILayerContainer.isImplementedBy(field))
     self.failUnless(field.required == 0, 'Value is %s' % field.required)
     self.failUnless(field.default == (), 'Value is %s' % str(str(field.default)))
     self.failUnless(field.searchable == 1, 'Value is %s' % field.searchable)
     self.failUnless(field.enforceVocabulary == 0,
                     'Value is %s' % field.enforceVocabulary)
     self.failUnless(field.multiValued == 0,
                     'Value is %s' % field.multiValued)
     self.failUnless(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
     self.failUnless(field.accessor == 'getEventType',
                     'Value is %s' % field.accessor)
     self.failUnless(field.mutator == 'setEventType',
                     'Value is %s' % field.mutator)
     self.failUnless(field.read_permission == View,
                     'Value is %s' % field.read_permission)
     self.failUnless(field.write_permission ==
                     ChangeEvents,
                     'Value is %s' % field.write_permission)
     self.failUnless(field.generateMode == 'veVc',
                     'Value is %s' % field.generateMode)
     self.failUnless(field.force == '', 'Value is %s' % field.force)
     self.failUnless(field.type == 'lines', 'Value is %s' % field.type)
     self.failUnless(isinstance(field.storage, AttributeStorage),
                     'Value is %s' % type(field.storage))
     self.failUnless(field.getLayerImpl('storage') == AttributeStorage(),
                     'Value is %s' % field.getLayerImpl('storage'))
     self.failUnless(ILayerContainer.isImplementedBy(field))
     self.failUnless(field.validators == EmptyValidator,
                     'Value is %s' % repr(field.validators))
     self.failUnless(isinstance(field.widget, KeywordWidget),
                     'Value is %s' % id(field.widget))
Ejemplo n.º 8
0
    def initializeLayers(self, instance, item=None, container=None):
        # scan each field looking for registered layers optionally
        # call its initializeInstance method and then the
        # initializeField method
        initializedLayers = []
        called = lambda x: x in initializedLayers

        for field in self.fields():
            if ILayerContainer.providedBy(field):
                layers = field.registeredLayers()
                for layer, obj in layers:
                    if ILayer.providedBy(obj):
                        if not called((layer, obj)):
                            obj.initializeInstance(instance, item, container)
                            # Some layers may have the same name, but
                            # different classes, so, they may still
                            # need to be initialized
                            initializedLayers.append((layer, obj))
                        obj.initializeField(instance, field)

        # Now do the same for objects registered at this level
        if ILayerContainer.providedBy(self):
            for layer, obj in self.registeredLayers():
                if (not called((layer, obj)) and
                        ILayer.providedBy(obj)):
                    obj.initializeInstance(instance, item, container)
                    initializedLayers.append((layer, obj))
    def test_abstractField(self):
        pro = self.createProosal()
        self.fill_out_proposal(pro)
        #dummy = self._dummy
        field = pro.getField('abstract')

        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.required == 0, 'Value is %s' % field.required)
        self.failUnless(field.default == '', 'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 1, 'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'getAbstract',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setAbstract',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == 'View',
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission ==
                        'Modify portal content',
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'text', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(field.getLayerImpl('storage') == AttributeStorage(),
                        'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.isImplementedBy(field))
        #self.failUnless(field.validators == NotRequiredTidyHTMLValidator,
        #                'Value is %s' % repr(field.validators))
        self.failUnless(isinstance(field.widget, RichWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(pro)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))

        self.failUnless(field.primary == 0, 'Value is %s' % field.primary)
        self.failUnless(field.default_content_type is None,
                        'Value is %s' % field.default_content_type)
        self.failUnless(field.default_output_type == 'text/html',
                        'Value is %s' % field.default_output_type)
        self.failUnless('text/html' in field.getAllowedContentTypes(pro))
Ejemplo n.º 10
0
    def test_imageField(self):
        dummy = self._dummy
        field = dummy.getField('image')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 1, 'Value is %s' % field.required)
        self.assertTrue(field.default is None, 'Value is %s' %
                        str(field.default))
        self.assertTrue(field.searchable == 0, 'Value is %s' %
                        field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0, 'Value is %s' %
                        field.isMetadata)
        self.assertTrue(field.accessor == 'getImage',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setImage',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission == ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'blob', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AnnotationStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') ==
            atapi.AnnotationStorage(migrate=True),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(
            field.validators ==
            "(('isNonEmptyFile', V_REQUIRED), " +
            "('checkImageMaxSize', V_REQUIRED))",
            'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.ImageWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
        self.assertTrue(field.primary == 1, 'Value is %s' % field.primary)
Ejemplo n.º 11
0
    def test_textField(self):
        dummy = self._dummy
        field = dummy.getField('text')

        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.required == 0, 'Value is %s' % field.required)
        self.failUnless(field.default == '', 'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 1, 'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'getText',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setText',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission ==
                        ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'text', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AnnotationStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(field.getLayerImpl('storage') == AnnotationStorage(migrate=True),
                        'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.validators == NotRequiredTidyHTMLValidator,
                        'Value is %s' % repr(field.validators))
        self.failUnless(isinstance(field.widget, RichWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))

        self.failUnless(field.primary == 1, 'Value is %s' % field.primary)
        self.failUnless(field.default_content_type is None,
                        'Value is %s' % field.default_content_type)
        self.failUnless(field.default_output_type == 'text/x-html-safe',
                        'Value is %s' % field.default_output_type)
        self.failUnless('text/html' in field.getAllowedContentTypes(dummy))
Ejemplo n.º 12
0
    def test_effectivedate(self):
        dummy = self._dummy
        field = dummy.getField('effectiveDate')

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 0)
        self.failUnlessEqual(field.default, None)
        self.failUnlessEqual(dummy.effective(), FLOOR_DATE)
        self.failUnless(field.searchable == 0)
        vocab = field.vocabulary
        self.failUnless(vocab == ())
        self.failUnless(field.enforceVocabulary == 0)
        self.failUnless(field.multiValued == 0)
        self.failUnless(field.isMetadata == 1)
        self.failUnless(field.mutator == 'setEffectiveDate')
        self.failUnless(field.read_permission == permissions.View)
        self.failUnless(field.write_permission ==
                        permissions.ModifyPortalContent)
        self.failUnless(field.generateMode == 'mVc')
        self.failUnless(field.force == '')
        self.failUnless(field.type == 'datetime')
        self.failUnless(isinstance(field.storage, MetadataStorage))
        self.failUnless(field.getLayerImpl('storage') == MetadataStorage())
        self.failUnless(field.validators == EmptyValidator)
        self.failUnless(isinstance(field.widget, CalendarWidget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList))
        self.failUnless(tuple(vocab) == ())
Ejemplo n.º 13
0
    def test_rights(self):
        dummy = self._dummy
        field = dummy.getField('rights')

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 0)
        self.failUnless(field.default == '')
        self.failUnless(field.searchable == 0)
        vocab = field.vocabulary
        self.failUnless(vocab == ())
        self.failUnless(field.enforceVocabulary == 0)
        self.failUnless(field.multiValued == 0)
        self.failUnless(field.isMetadata == 1)
        self.failUnless(field.accessor == 'Rights')
        self.failUnless(field.mutator == 'setRights')
        self.failUnless(field.read_permission == permissions.View)
        self.failUnless(field.write_permission ==
                        permissions.ModifyPortalContent)
        self.failUnless(field.generateMode == 'mVc')
        self.failUnless(field.force == '')
        self.failUnless(field.type == 'text')
        self.failUnless(isinstance(field.storage, MetadataStorage))
        self.failUnless(field.getLayerImpl('storage') == MetadataStorage())
        self.failUnless(field.validators == EmptyValidator)
        self.failUnless(isinstance(field.widget, TextAreaWidget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList))
        self.failUnless(tuple(vocab) == ())
Ejemplo n.º 14
0
    def test_expirationdate(self):
        dummy = self._dummy
        field = dummy.getField('expirationDate')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0)
        self.assertEqual(field.default, None)
        self.assertEqual(dummy.expires(), CEILING_DATE)
        self.assertTrue(field.searchable == 0)
        vocab = field.vocabulary
        self.assertTrue(vocab == ())
        self.assertTrue(field.enforceVocabulary == 0)
        self.assertTrue(field.multiValued == 0)
        self.assertTrue(field.isMetadata == 1)
        self.assertTrue(field.mutator == 'setExpirationDate')
        self.assertTrue(field.read_permission == permissions.View)
        self.assertTrue(field.write_permission ==
                        permissions.ModifyPortalContent)
        self.assertTrue(field.generateMode == 'mVc')
        self.assertTrue(field.force == '')
        self.assertTrue(field.type == 'datetime')
        self.assertTrue(isinstance(field.storage, atapi.MetadataStorage))
        self.assertTrue(field.getLayerImpl('storage') == atapi.MetadataStorage())
        self.assertTrue(field.validators == EmptyValidator)
        self.assertTrue(isinstance(field.widget, atapi.CalendarWidget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList))
        self.assertTrue(tuple(vocab) == ())
Ejemplo n.º 15
0
    def test_description(self):
        dummy = self._dummy
        field = dummy.getField('description')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0)
        self.assertTrue(field.default == '')
        self.assertTrue(field.searchable == 1)
        vocab = field.vocabulary
        self.assertTrue(vocab == ())
        self.assertTrue(field.enforceVocabulary == 0)
        self.assertTrue(field.multiValued == 0)
        self.assertTrue(field.isMetadata == 1)
        self.assertTrue(field.accessor == 'Description')
        self.assertTrue(field.mutator == 'setDescription')
        self.assertTrue(field.read_permission == permissions.View)
        self.assertTrue(field.write_permission ==
                        permissions.ModifyPortalContent)
        self.assertTrue(field.generateMode == 'mVc')
        self.assertTrue(field.force == '')
        self.assertTrue(field.type == 'text')
        self.assertTrue(isinstance(field.storage, atapi.MetadataStorage))
        self.assertTrue(field.getLayerImpl('storage') == atapi.MetadataStorage())
        self.assertTrue(field.validators == EmptyValidator)
        self.assertTrue(isinstance(field.widget, atapi.TextAreaWidget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList))
        self.assertTrue(tuple(vocab) == ())
Ejemplo n.º 16
0
    def test_relateditems(self):
        dummy = self._dummy
        field = dummy.getField('relatedItems')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertEqual(field.required, False)
        self.assertEqual(field.default, None)
        self.assertEqual(field.searchable, False)
        self.assertEqual(getattr(field, 'primary', None), None)
        vocab = field.vocabulary
        self.assertEqual(vocab, ())
        self.assertEqual(field.enforceVocabulary, False)
        self.assertEqual(field.multiValued, True)
        self.assertEqual(field.isMetadata, True)
        self.assertEqual(field.accessor, 'getRelatedItems')
        self.assertEqual(field.mutator, 'setRelatedItems')
        self.assertEqual(field.edit_accessor, 'getRawRelatedItems')
        self.assertEqual(field.read_permission, View)
        self.assertEqual(field.write_permission, ModifyPortalContent)
        self.assertEqual(field.generateMode, 'veVc')
        self.assertEqual(field.force, '')
        self.assertEqual(field.type, 'reference')
        self.assertTrue(isinstance(field.storage, AttributeStorage))
        self.assertTrue(field.getLayerImpl('storage') == AttributeStorage())
        self.assertEqual(field.validators, EmptyValidator)
        self.assertTrue(isinstance(field.widget, ReferenceBrowserWidget))
        self.assertTrue(field.widget.allow_sorting, u'field and widget need to enable sorting')
        self.assertTrue(field.referencesSortable, u'field and widget need to enable sorting')

        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, DisplayList))
Ejemplo n.º 17
0
    def test_id(self):
        dummy = self._dummy
        field = dummy.getField('id')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertEqual(field.required, False)
        self.assertEqual(field.default, None)
        self.assertEqual(field.searchable, True)
        self.assertEqual(getattr(field, 'primary', None), None)
        vocab = field.vocabulary
        self.assertEqual(vocab, ())
        self.assertEqual(field.enforceVocabulary, False)
        self.assertEqual(field.multiValued, False)
        self.assertEqual(field.isMetadata, False)
        self.assertEqual(field.accessor, 'getId')
        self.assertEqual(field.mutator, 'setId')
        self.assertEqual(field.edit_accessor, 'getRawId')
        self.assertEqual(field.read_permission, View)
        self.assertEqual(field.write_permission, ModifyPortalContent)
        self.assertEqual(field.generateMode, 'veVc')
        self.assertEqual(field.force, '')
        self.assertEqual(field.type, 'string')
        self.assertTrue(isinstance(field.storage, AttributeStorage))
        self.assertTrue(field.getLayerImpl('storage') == AttributeStorage())
        self.assertEqual(field.validators, idValidator)
        self.assertTrue(isinstance(field.widget, IdWidget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, DisplayList))
        self.assertEqual(tuple(vocab), ())
Ejemplo n.º 18
0
    def test_description(self):
        dummy = self._dummy
        field = dummy.getField('description')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertEqual(field.required, False)
        self.assertEqual(field.default, '')
        self.assertEqual(field.searchable, True)
        self.assertEqual(field.primary, False)
        vocab = field.vocabulary
        self.assertEqual(vocab, ())
        self.assertEqual(field.enforceVocabulary, False)
        self.assertEqual(field.multiValued, False)
        self.assertEqual(field.isMetadata, True)
        self.assertEqual(field.accessor, 'Description')
        self.assertEqual(field.mutator, 'setDescription')
        self.assertEqual(field.edit_accessor, 'getRawDescription')
        self.assertEqual(field.read_permission, View)
        self.assertEqual(field.write_permission, ModifyPortalContent)
        self.assertEqual(field.generateMode, 'mVc')
        #self.assertTrue(field.generateMode == 'veVc', field.generateMode)
        self.assertEqual(field.force, '')
        self.assertEqual(field.type, 'text')
        self.assertTrue(isinstance(field.storage, MetadataStorage))
        self.assertTrue(field.getLayerImpl('storage') == MetadataStorage())
        self.assertEqual(field.validators, EmptyValidator)
        self.assertTrue(isinstance(field.widget, TextAreaWidget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, DisplayList))
        self.assertEqual(tuple(vocab), ())
Ejemplo n.º 19
0
    def test_language(self):
        default = LANGUAGE_DEFAULT
        dummy = self._dummy
        field = dummy.getField('language')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0)
        self.assertTrue(field.default == LANGUAGE_DEFAULT)
        self.assertTrue(field.searchable == 0)
        vocab = field.vocabulary
        self.assertTrue(vocab == 'languages')
        self.assertTrue(field.enforceVocabulary == 0)
        self.assertTrue(field.multiValued == 0)
        self.assertTrue(field.isMetadata == 1)
        self.assertTrue(field.accessor == 'Language')
        self.assertTrue(field.mutator == 'setLanguage')
        self.assertTrue(field.read_permission == permissions.View)
        self.assertTrue(field.write_permission ==
                        permissions.ModifyPortalContent)
        self.assertTrue(field.generateMode == 'mVc')
        self.assertTrue(field.force == '')
        self.assertTrue(field.type == 'string')
        self.assertTrue(isinstance(field.storage, atapi.MetadataStorage))
        self.assertTrue(field.getLayerImpl('storage') == atapi.MetadataStorage())
        self.assertTrue(field.validators == EmptyValidator)
        self.assertTrue(isinstance(field.widget, atapi.LanguageWidget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList))
        self.assertTrue(vocab == dummy.languages())
Ejemplo n.º 20
0
    def test_title(self):
        dummy = self._dummy
        field = dummy.getField('title')

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 1)
        self.failUnless(field.default == '')
        self.failUnless(field.searchable == 1)
        self.failUnless(field.vocabulary == ())
        self.failUnless(field.enforceVocabulary == 0)
        self.failUnless(field.multiValued == 0)
        self.failUnless(field.isMetadata == 0)
        self.failUnless(field.accessor == 'Title')
        self.failUnless(field.mutator == 'setTitle')
        self.failUnless(field.read_permission == permissions.View)
        self.failUnless(field.write_permission ==
                        permissions.ModifyPortalContent)
        self.failUnless(field.generateMode == 'veVc')
        self.failUnless(field.force == '')
        self.failUnless(field.type == 'string')
        self.failUnless(isinstance(field.storage, AttributeStorage))
        self.failUnless(field.getLayerImpl('storage') == AttributeStorage())
        self.failUnless(field.validators == ())
        self.failUnless(isinstance(field.widget, StringWidget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList))
        self.failUnless(tuple(vocab) == ())
Ejemplo n.º 21
0
    def test_endDateField(self):
        dummy = self._dummy
        field = dummy.getField('endDate')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 1, 'Value is %s' % field.required)
        self.assertTrue(field.default is None, 'Value is %s' %
                        str(field.default))
        self.assertTrue(field.default_method == DateTime,
                        'Value is %s' % str(field.default_method))
        self.assertTrue(field.searchable is False,
                        'Value is %s' % field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0, 'Value is %s' %
                        field.isMetadata)
        self.assertTrue(field.accessor == 'end',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setEndDate',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission ==
                        ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'datetime', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.validators == (),
                        'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.DatetimeWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
    def test_proposerEmailField(self):
        pro = self.createProosal()
        self.fill_out_proposal(pro)
        #dummy = self._dummy
        field = pro.getField('proposerEmail')

        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.required == 1, 'Value is %s' % field.required)
        self.failUnless(field.default == '',
                        'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 0,
                        'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'getProposerEmail',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setProposerEmail',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == 'View',
                        'Value is %s' % field.read_permission)
        self.failUnless(
            field.write_permission == 'uwosh_grants: View proposer details',
            'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'string', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(
            field.getLayerImpl('storage') == AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.isImplementedBy(field))
        #self.failUnless(field.validators == ('isEmail',1),
        #                'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(pro)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 23
0
    def test_fileField(self):
        dummy = self._dummy
        field = dummy.getField('file')

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 1, 'Value is %s' % field.required)
        self.failIf(field.default, 'Value is %s' % str(field.default))
        self.failUnless(field.searchable == True,
                        'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'getFile',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setFile',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission == ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'blob', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AnnotationStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(
            field.getLayerImpl('storage') == AnnotationStorage(migrate=True),
            'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(
            field.validators ==
            "(('isNonEmptyFile', V_REQUIRED), ('checkFileMaxSize', V_REQUIRED))",
            'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, FileWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
        self.failUnless(field.primary == 1, 'Value is %s' % field.primary)
Ejemplo n.º 24
0
    def test_remoteUrlField(self):
        dummy = self._dummy
        field = dummy.getField('remoteUrl')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 1, 'Value is %s' % field.required)
        self.assertTrue(field.default == 'http://',
                        'Value is %s' % str(field.default))
        self.assertTrue(field.searchable == 1,
                        'Value is %s' % field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.assertTrue(field.accessor == 'getRemoteUrl',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setRemoteUrl',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission == ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'string', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.validators == (),
                        'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
        self.assertTrue(field.primary == 1, 'Value is %s' % field.primary)
Ejemplo n.º 25
0
    def test_remoteUrlField(self):
        dummy = self._dummy
        field = dummy.getField('remoteUrl')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 1, 'Value is %s' % field.required)
        self.assertTrue(field.default == 'http://',
                        'Value is %s' % str(field.default))
        self.assertTrue(field.searchable == 1, 'Value is %s' %
                        field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0, 'Value is %s' %
                        field.isMetadata)
        self.assertTrue(field.accessor == 'getRemoteUrl',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setRemoteUrl',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission == ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'string', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.validators == (),
                        'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
        self.assertTrue(field.primary == 1, 'Value is %s' % field.primary)
Ejemplo n.º 26
0
    def test_contactEmailField(self):
        dummy = self._dummy
        field = dummy.getField('contactEmail')

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 0, 'Value is %s' % field.required)
        self.failUnless(field.default == '',
                        'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 1,
                        'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'contact_email',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setContactEmail',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission == ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'string', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(
            field.getLayerImpl('storage') == AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.validators == EmailValidator,
                        'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 27
0
    def test_endDateField(self):
        dummy = self._ATCT
        field = dummy.getField('endDate')

        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.required == 1, 'Value is %s' % field.required)
        self.failUnless(field.default == None, 'Value is %s' % str(field.default))
        self.failUnless(field.default_method == DateTime,
                        'Value is %s' % str(field.default_method))
        self.failUnless(field.searchable == False, 'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'end',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setEndDate',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission ==
                        ChangeEvents,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'datetime', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(field.getLayerImpl('storage') == AttributeStorage(),
                        'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.validators == (),
                        'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, CalendarWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
    def test_proposerIdField(self):
        pro = self.createProosal()
        self.fill_out_proposal(pro)
        #dummy = self._dummy
        field = pro.getField('proposerId')

        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.required == 1, 'Value is %s' % field.required)
        self.failUnless(field.default == '', 'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 1, 'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 1, 'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'getProposerId',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setProposerId',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == 'View',
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission ==
                        'uwosh_grants: View proposer details',
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'string', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(field.getLayerImpl('storage') == AttributeStorage(),
                        'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.isImplementedBy(field))
        #self.failUnless(field.validators == EmptyValidator,
        #                'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(pro)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))    
Ejemplo n.º 29
0
    def test_contactEmailField(self):
        dummy = self._dummy
        field = dummy.getField('contactEmail')

        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.required == 0, 'Value is %s' % field.required)
        self.failUnless(field.default == '', 'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 1, 'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'contact_email',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setContactEmail',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission ==
                        ChangeEvents,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'string', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(field.getLayerImpl('storage') == AttributeStorage(),
                        'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.isImplementedBy(field))
        self.failUnless(field.validators == EmailValidator,
                        'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 30
0
    def test_eventUrlField(self):
        dummy = self._dummy
        field = dummy.getField('eventUrl')

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 0, 'Value is %s' % field.required)
        self.failUnless(field.default == '', 'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 1, 'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'event_url',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setEventUrl',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission ==
                        ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'string', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(field.getLayerImpl('storage') == AttributeStorage(),
                        'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnlessEqual(field.validators, URLValidator)
        self.failUnless(isinstance(field.widget, StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 31
0
    def test_contactPhoneField(self):
        field = self.obj.getField('contactPhone')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0, 'Value is %s' % field.required)
        self.assertTrue(field.default == '', 'Value is %s' % str(field.default))
        self.assertTrue(field.searchable == 1, 'Value is %s' % field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
        self.assertTrue(field.accessor == 'contact_phone',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setContactPhone',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission ==
                        ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'string', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(field.getLayerImpl('storage') == atapi.AttributeStorage(),
                        'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertEqual(field.validators, EmptyValidator)
        self.assertTrue(isinstance(field.widget, atapi.StringWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(self.obj)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 32
0
 def test_subjectField(self):
     dummy = self._dummy
     field = dummy.getField('subject')
     self.assertTrue(ILayerContainer.providedBy(field))
     self.assertTrue(field.required == 0, 'Value is %s' % field.required)
     self.assertTrue(field.default == (), 'Value is %s' %
                     str(str(field.default)))
     self.assertTrue(field.searchable == 1, 'Value is %s' %
                     field.searchable)
     self.assertTrue(field.enforceVocabulary == 0,
                     'Value is %s' % field.enforceVocabulary)
     self.assertTrue(field.multiValued == 1,
                     'Value is %s' % field.multiValued)
     self.assertTrue(field.isMetadata == 1, 'Value is %s' %
                     field.isMetadata)
     self.assertTrue(field.accessor == 'Subject',
                     'Value is %s' % field.accessor)
     self.assertTrue(field.mutator == 'setSubject',
                     'Value is %s' % field.mutator)
     self.assertTrue(field.read_permission == View,
                     'Value is %s' % field.read_permission)
     self.assertTrue(field.write_permission ==
                     ModifyPortalContent,
                     'Value is %s' % field.write_permission)
     self.assertTrue(field.generateMode == 'mVc',
                     'Value is %s' % field.generateMode)
     self.assertTrue(field.force == '', 'Value is %s' % field.force)
     self.assertTrue(field.type == 'lines', 'Value is %s' % field.type)
     self.assertTrue(isinstance(field.storage, atapi.MetadataStorage),
                     'Value is %s' % type(field.storage))
     self.assertTrue(
         field.getLayerImpl('storage') == atapi.MetadataStorage(),
         'Value is %s' % field.getLayerImpl('storage'))
     self.assertTrue(ILayerContainer.providedBy(field))
     self.assertTrue(field.validators == EmptyValidator,
                     'Value is %s' % repr(field.validators))
     self.assertTrue(isinstance(field.widget, atapi.TagsWidget),
                     'Value is %s' % id(field.widget))
    def test_limitNumberField(self):
        dummy = self._dummy
        field = dummy.getField('limitNumber')
        field_vocab = BooleanField._properties.get('vocabulary', ())

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 0, 'Value is %s' % field.required)
        self.failUnless(field.default == False,
                        'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 0,
                        'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == field_vocab,
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'getLimitNumber',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setLimitNumber',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission == ChangeTopics,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'boolean', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(
            field.getLayerImpl('storage') == AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(field.validators == EmptyValidator,
                        'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, BooleanWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(
            tuple(vocab) == tuple([x[0] for x in field_vocab]),
            'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 34
0
    def test_limitNumberField(self):
        dummy = self._dummy
        field = dummy.getField('limitNumber')
        field_vocab = BooleanField._properties.get('vocabulary', ())

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0, 'Value is %s' % field.required)
        self.assertFalse(field.default, 'Value is %s' %
                         str(field.default))
        self.assertTrue(field.searchable == 0, 'Value is %s' %
                        field.searchable)
        self.assertTrue(field.vocabulary == field_vocab,
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0, 'Value is %s' %
                        field.isMetadata)
        self.assertTrue(field.accessor == 'getLimitNumber',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setLimitNumber',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission == ChangeTopics,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'boolean', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(field.validators == EmptyValidator,
                        'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.BooleanWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == tuple([x[0] for x in field_vocab]),
                        'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 35
0
    def test_customViewField(self):
        # XXX not in the current version
        return
        dummy = self._dummy
        field = dummy.getField('customView')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0, 'Value is %s' % field.required)
        self.assertFalse(field.default, 'Value is %s' %
                         str(field.default))
        self.assertTrue(field.searchable == 0, 'Value is %s' %
                        field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0, 'Value is %s' %
                        field.isMetadata)
        self.assertTrue(field.accessor == 'getCustomView',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setCustomView',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission == ChangeTopics,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'boolean', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(field.validators == EmptyValidator,
                        'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.BooleanWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
    def test_customViewField(self):
        # XXX not in the current version
        return
        dummy = self._dummy
        field = dummy.getField('customView')

        self.failUnless(ILayerContainer.providedBy(field))
        self.failUnless(field.required == 0, 'Value is %s' % field.required)
        self.failUnless(field.default == False,
                        'Value is %s' % str(field.default))
        self.failUnless(field.searchable == 0,
                        'Value is %s' % field.searchable)
        self.failUnless(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.failUnless(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.failUnless(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.failUnless(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.failUnless(field.accessor == 'getCustomView',
                        'Value is %s' % field.accessor)
        self.failUnless(field.mutator == 'setCustomView',
                        'Value is %s' % field.mutator)
        self.failUnless(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.failUnless(field.write_permission == ChangeTopics,
                        'Value is %s' % field.write_permission)
        self.failUnless(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.failUnless(field.force == '', 'Value is %s' % field.force)
        self.failUnless(field.type == 'boolean', 'Value is %s' % field.type)
        self.failUnless(isinstance(field.storage, AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.failUnless(
            field.getLayerImpl('storage') == AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.failUnless(field.validators == EmptyValidator,
                        'Value is %s' % str(field.validators))
        self.failUnless(isinstance(field.widget, BooleanWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.failUnless(isinstance(vocab, DisplayList),
                        'Value is %s' % type(vocab))
        self.failUnless(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 37
0
    def test_recurrenceField(self):
        field = self.obj.getField('recurrence')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0, 'Value is %s' % field.required)
        self.assertTrue(field.default == '', 'Value is %s' % str(field.default))
        self.assertTrue(field.searchable == False, 'Value is %s' % field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0, 'Value is %s' % field.isMetadata)
        self.assertTrue(field.accessor == 'getRecurrence',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setRecurrence',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission ==
                        ModifyPortalContent,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'string', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AnnotationStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(field.getLayerImpl('storage') == atapi.AnnotationStorage(),
                        'Value is %s' % field.getLayerImpl('storage'))

        # flatten nested tuples
        valis = list(itertools.chain(*field.validators))
        is_recval = False
        for vali in valis:
            is_recval = is_recval or isinstance(vali, RecurrenceValidator)
        self.assertTrue(is_recval)

        self.assertTrue(isinstance(field.widget, RecurrenceWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(self.obj)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 38
0
    def test_itemCountField(self):
        dummy = self._dummy
        field = dummy.getField('itemCount')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0, 'Value is %s' % field.required)
        self.assertTrue(field.default == 0, 'Value is %s' % str(field.default))
        self.assertTrue(field.searchable == 0,
                        'Value is %s' % field.searchable)
        self.assertTrue(field.vocabulary == (),
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary == 0,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.assertTrue(field.accessor == 'getItemCount',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setItemCount',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission == ChangeTopics,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'integer', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(field.validators == EmptyValidator,
                        'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.IntegerWidget),
                        'Value is %s' % id(field.widget))
        vocab = field.Vocabulary(dummy)
        self.assertTrue(isinstance(vocab, atapi.DisplayList),
                        'Value is %s' % type(vocab))
        self.assertTrue(tuple(vocab) == (), 'Value is %s' % str(tuple(vocab)))
Ejemplo n.º 39
0
    def test_customViewFieldsField(self):
        # XXX not in the current version
        return
        dummy = self._dummy
        field = dummy.getField('customViewFields')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0, 'Value is %s' % field.required)
        self.assertTrue(field.default == ('Title', ),
                        'Value is %s' % str(field.default))
        self.assertTrue(field.searchable == 0,
                        'Value is %s' % field.searchable)
        self.assertTrue(field.vocabulary == 'listMetaDataFields',
                        'Value is %s' % str(field.vocabulary))
        self.assertTrue(field.enforceVocabulary,
                        'Value is %s' % field.enforceVocabulary)
        self.assertTrue(field.multiValued == 0,
                        'Value is %s' % field.multiValued)
        self.assertTrue(field.isMetadata == 0,
                        'Value is %s' % field.isMetadata)
        self.assertTrue(field.accessor == 'getCustomViewFields',
                        'Value is %s' % field.accessor)
        self.assertTrue(field.mutator == 'setCustomViewFields',
                        'Value is %s' % field.mutator)
        self.assertTrue(field.read_permission == View,
                        'Value is %s' % field.read_permission)
        self.assertTrue(field.write_permission == ChangeTopics,
                        'Value is %s' % field.write_permission)
        self.assertTrue(field.generateMode == 'veVc',
                        'Value is %s' % field.generateMode)
        self.assertTrue(field.force == '', 'Value is %s' % field.force)
        self.assertTrue(field.type == 'lines', 'Value is %s' % field.type)
        self.assertTrue(isinstance(field.storage, atapi.AttributeStorage),
                        'Value is %s' % type(field.storage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.AttributeStorage(),
            'Value is %s' % field.getLayerImpl('storage'))
        self.assertTrue(field.validators == EmptyValidator,
                        'Value is %s' % str(field.validators))
        self.assertTrue(isinstance(field.widget, atapi.InAndOutWidget),
                        'Value is %s' % id(field.widget))
Ejemplo n.º 40
0
    def test_allowdiscussion(self):
        dummy = self._dummy
        field = dummy.getField('allowDiscussion')

        self.assertTrue(ILayerContainer.providedBy(field))
        self.assertTrue(field.required == 0)
        self.assertTrue(field.default == None)
        self.assertTrue(field.searchable == 0)
        self.assertTrue(field.multiValued == 0)
        self.assertTrue(field.isMetadata == 1)
        self.assertTrue(field.accessor == 'isDiscussable')
        self.assertTrue(field.mutator == 'allowDiscussion')
        self.assertTrue(field.edit_accessor == 'editIsDiscussable')
        self.assertTrue(field.read_permission == permissions.View)
        self.assertTrue(
            field.write_permission == permissions.ModifyPortalContent)
        self.assertTrue(field.generateMode == 'mVc')
        self.assertTrue(field.force == '')
        self.assertTrue(field.type == 'boolean')
        self.assertTrue(isinstance(field.storage, atapi.MetadataStorage))
        self.assertTrue(
            field.getLayerImpl('storage') == atapi.MetadataStorage())
        self.assertTrue(field.validators == EmptyValidator)
        self.assertTrue(isinstance(field.widget, atapi.BooleanWidget))
Ejemplo n.º 41
0
 def initializeLayers(self, instance, item=None, container=None):
     """Layer initialization"""
     for s in self.getSchemas():
         if ILayerContainer.providedBy(s):
             s.initializeLayers(instance, item, container)
Ejemplo n.º 42
0
 def cleanupLayers(self, instance, item=None, container=None):
     """Layer cleaning"""
     for s in self.getSchemas():
         if ILayerContainer.providedBy(s):
             s.cleanupLayers(instance, item, container)