def test_get_relative_dottedname(self):
        builder = Builder('zcml').at_path(self.temp_directory.joinpath('configure.zcml'))

        self.assertEqual(
            '.browser.views.EditView',

            builder.get_relative_dottedname(self.temp_directory.joinpath('browser', 'views.py'),
                                            'EditView'))
Beispiel #2
0
    def _create_admin_unit(self):
        if not self._with_admin_unit:
            return None

        builder = Builder('admin_unit').having(
            **self._admin_unit_args).as_current_admin_unit()

        # wrapping org-unit
        if self._with_org_unit:
            builder = builder.having(unit_id=self._org_unit_args['unit_id'],
                                     title=self._org_unit_args['title'])
        return create(builder)
Beispiel #3
0
    def get_configure_zcml(self):
        """Returns the configure.zcml builder.
        """
        if self.configure_zcml is not None:
            return self.configure_zcml

        self.configure_zcml = Builder('zcml')
        return self.configure_zcml
    def test_xls_in_zip_file(self, browser):
        ticket_builder = Builder('ticket')
        ticket_builder.titled(u'T\xc3st')
        ticket_builder.with_id('1')
        ticket_builder.having(dueDate=DateTime(2011, 11, 10, 17, 14, 35),
                              ticket_description='<p>This is a<br />test.</p>')
        ticket_builder.within(self.ticketbox)

        with freeze(datetime(2011, 2, 3, 5, 7, 11)):
            create(ticket_builder)

        browser.login()
        browser.visit(self.ticketbox, view='zip_export')
        self.assertEquals('application/zip', browser.headers['Content-Type'])

        zipfile = ZipFile(StringIO(browser.contents))
        self.assertEquals(['ticketbox.xlsx'], zipfile.namelist())

        xlsx = zipfile.read('ticketbox.xlsx')

        workbook = open_workbook(file_contents=xlsx)
        sheet = workbook.sheet_by_index(0)

        data = map(sheet.row_values, range(sheet.nrows))
        headers = data.pop(0)
        data = map(
            lambda row: dict(zip(headers, row)),
            data
        )
        self.maxDiff = None
        self.assertEquals(
            first=[
                {
                    u'Created': u'03.02.2011 05:07',
                    u'Due date': u'10.11.2011 17:14',
                    u'No.': u'1',
                    u'Description': u' This is a test. ',
                    u'Releases': u'',
                    u'Creator': u'test_user_1_',
                    u'Responsible': u'',
                    u'Watched release': u'',
                    u'Priorities': u'',
                    u'State': u'',
                    u'Variety': u'',
                    u'Title': u'T\xc3st',
                    u'Area': u'',
                }
            ],
            second=data
        )
    def _create_test_content(self):
        """
        This method can be used to set up some test content. The method
        may be called from various test case, but not all (if they require
        very special test data).
        """
        self.page = create(Builder('sl content page'))

        slick_config = json.dumps(
            {'arrows': 'false', 'autoplaySpeed': 1000, 'autoplay': 'false'}
        )
        block_builder = Builder('sliderblock')
        block_builder.within(self.page)
        block_builder.titled('SliderBlock title')
        block_builder.having(slick_config=slick_config)
        self.block = create(block_builder)

        create(Builder('slider pane')
               .within(self.block)
               .titled(u'Pane 1')
               .with_dummy_image())
        create(Builder('slider pane')
               .within(self.block)
               .titled(u'Pane 2')
               .with_dummy_image())
Beispiel #6
0
 def __init__(self, session):
     self.session = session
     self.path = None
     self.name = None
     self.version = '1.0.0.dev0'
     self.namespaces = None
     self.package = Builder('subpackage')
     self.directories = []
     self.files = []
     self.profiles = []
    def test_xlsx_export(self):
        ticketbox = create(Builder('ticket box')
                           .titled(u'My Tickät Box'))

        ticket_builder = Builder('ticket')
        ticket_builder.titled(u'Täst')
        ticket_builder.with_id('1')
        ticket_builder.having(dueDate=DateTime(2010, 11, 10, 17, 14, 35),
                              ticket_description="<p>This is a<br />test.</p>")
        ticket_builder.within(ticketbox)

        with freeze(datetime(2010, 11, 1, 8, 25, 20)):
            create(ticket_builder)

        export_view = ticketbox.restrictedTraverse('tickets_export_xlsx')
        response = export_view()

        workbook = open_workbook(file_contents=response)
        sheet = workbook.sheet_by_index(0)

        data = map(sheet.row_values, range(sheet.nrows))
        headers = data.pop(0)
        data = map(
            lambda row: dict(zip(headers, row)),
            data
        )
        self.maxDiff = None
        self.assertEquals(
            first=[
                {
                    u'Created': u'01.11.2010 08:25',
                    u'Due date': u'10.11.2010 17:14',
                    u'No.': u'1',
                    u'Description': u' This is a test. ',
                    u'Releases': u'',
                    u'Creator': u'test_user_1_',
                    u'Responsible': u'',
                    u'Watched release': u'',
                    u'Priorities': u'',
                    u'State': u'',
                    u'Variety': u'',
                    u'Title': u'Täst',
                    u'Area': u'',
                }
            ],
            second=data
        )
    def test_inclusion_does_not_use_path_too_early(self):
        # The problem is that at_path may be set just before create() by a another builder.
        # Therefore "building" the ZCML should not depend on the path, but creating can.

        main_builder = Builder('zcml')
        sub_builder = Builder('zcml')
        main_builder.include(sub_builder)

        main_builder.at_path(self.temp_directory.joinpath('configure.zcml'))
        sub_builder.at_path(self.temp_directory.joinpath('browser', 'configure.zcml'))

        self.assert_zcml(
            ('<configure xmlns="http://namespaces.zope.org/zope">',
             '  <include package=".browser"/>',
             '</configure>'),
            main_builder)
    def test_nested_structures(self):
        builder = Builder('zcml')
        condition = builder.create_node('configure', **{'condition': 'installed foobar'})
        builder.include('foobar', parent=condition)
        builder.create_node('something', condition)

        self.assert_zcml(
            ('<configure xmlns="http://namespaces.zope.org/zope">',
             '  <configure condition="installed foobar">',
             '    <include package="foobar"/>',
             '    <something/>',
             '  </configure>',
             '</configure>'),
            builder)
Beispiel #10
0
    def test_is_decided_is_false_if_the_agendaitem_is_not_decided(self):
        agenda_item = create(Builder('agenda_item')
                             .having(title=u'Simple', meeting=self.meeting))

        self.assertFalse(agenda_item.is_decided())
 def setUp(self):
     super(TestManualJournalEntry, self).setUp()
     self.dossier = create(Builder('dossier'))
     self.contactfolder = create(Builder('contactfolder'))
     toggle_feature(IContactSettings, enabled=True)
    def setUp(self):
        super(TestAlphabeticalTOC, self).setUp()
        self.container = create(Builder('committee_container'))

        # freeze date to make sure the default period is 2016
        with freeze(datetime(2016, 12, 3)):
            self.committee = create(
                Builder('committee').within(self.container))
        self.committee_model = self.committee.load_model()
        self.period = create(
            Builder('period').having(title=u'2010',
                                     date_from=date(2010, 1, 1),
                                     date_to=date(2010, 12, 31),
                                     committee=self.committee_model))

        self.meeting_before = create(
            Builder('meeting').having(committee=self.committee_model,
                                      start=pytz.UTC.localize(
                                          datetime(2009, 12, 31, 23, 45)),
                                      protocol_start_page_number=99))

        self.meeting1 = create(
            Builder('meeting').having(committee=self.committee_model,
                                      start=pytz.UTC.localize(
                                          datetime(2010, 1, 1, 10, 30)),
                                      protocol_start_page_number=33))
        self.meeting2 = create(
            Builder('meeting').having(committee=self.committee_model,
                                      start=pytz.UTC.localize(
                                          datetime(2010, 12, 31, 18, 30)),
                                      protocol_start_page_number=129))

        self.meeting_after = create(
            Builder('meeting').having(committee=self.committee_model,
                                      start=pytz.UTC.localize(
                                          datetime(2011, 1, 1, 0, 0)),
                                      protocol_start_page_number=99))

        proposal1_1 = create(
            Builder('proposal_model').having(
                submitted_title=u'proposal 1',
                committee=self.committee_model,
                workflow_state=Proposal.STATE_DECIDED.name,
                repository_folder_title=u'\xc4 Business',
                dossier_reference_number='1.1.4 / 1',
                int_id=1))
        proposal1_2 = create(
            Builder('proposal_model').having(
                submitted_title=u'\xc4a proposal',
                committee=self.committee_model,
                workflow_state=Proposal.STATE_DECIDED.name,
                repository_folder_title=u'\xc4 Business',
                dossier_reference_number='1.1.4 / 2',
                int_id=2))
        proposal1_3 = create(
            Builder('proposal_model').having(
                submitted_title=u'aa proposal',
                committee=self.committee_model,
                workflow_state=Proposal.STATE_DECIDED.name,
                repository_folder_title=u'\xc4 Business',
                dossier_reference_number='1.1.4 / 1',
                int_id=5))

        proposal2_1 = create(
            Builder('proposal_model').having(
                submitted_title=u'Proposal 3',
                committee=self.committee_model,
                workflow_state=Proposal.STATE_DECIDED.name,
                repository_folder_title='A Business',
                dossier_reference_number='10.1.4 / 1',
                int_id=3))
        proposal2_2 = create(
            Builder('proposal_model').having(
                submitted_title=u'Anything goes',
                committee=self.committee_model,
                workflow_state=Proposal.STATE_DECIDED.name,
                submitted_description=u'Really, Anything.',
                repository_folder_title='Other Stuff',
                dossier_reference_number='3.1.4 / 77',
                int_id=4))

        create(
            Builder('agenda_item').having(
                meeting=self.meeting_before,
                title=u'I am before period start',
                decision_number=1,
            ))

        create(
            Builder('agenda_item').having(
                meeting=self.meeting1,
                proposal=proposal1_1,
                decision_number=2,
            ))
        create(
            Builder('agenda_item').having(
                meeting=self.meeting1,
                proposal=proposal1_2,
                decision_number=3,
            ))
        create(
            Builder('agenda_item').having(
                meeting=self.meeting1,
                proposal=proposal1_3,
                decision_number=8,
            ))
        create(
            Builder('agenda_item').having(
                meeting=self.meeting2,
                proposal=proposal2_1,
                decision_number=4,
            ))
        create(
            Builder('agenda_item').having(
                meeting=self.meeting2,
                proposal=proposal2_2,
                decision_number=5,
            ))
        create(
            Builder('agenda_item').having(
                meeting=self.meeting2,
                title=u'No Proposal here',
                decision_number=6,
            ))
        create(
            Builder('agenda_item').having(
                meeting=self.meeting2,
                title=u'Nahhh not here either',
                description=u'But a description!',
                decision_number=7,
            ))

        create(
            Builder('agenda_item').having(meeting=self.meeting2,
                                          is_paragraph=True,
                                          title=u'I am a paragraph'))

        create(
            Builder('agenda_item').having(
                meeting=self.meeting_after,
                title=u'I am after period end',
                decision_number=1,
            ))

        # freeze date to make sure the default period is 2016
        with freeze(datetime(2016, 12, 3)):
            self.other_committee = create(
                Builder('committee').within(self.container))
        self.other_committee_model = self.other_committee.load_model()
        self.other_period = create(
            Builder('period').having(title=u'2010',
                                     date_from=date(2010, 1, 1),
                                     date_to=date(2010, 12, 31),
                                     committee=self.other_committee_model))

        self.other_meeting = create(
            Builder('meeting').having(committee=self.other_committee_model,
                                      start=pytz.UTC.localize(
                                          datetime(2010, 12, 31, 18, 30)),
                                      protocol_start_page_number=33))
        create(
            Builder('agenda_item').having(
                meeting=self.other_meeting,
                title=u'I should not appear in the test-toc',
                decision_number=77,
            ))
 def setUp(self):
     super(TestForwarding, self).setUp()
     self.inbox = create(Builder('inbox'))
 def create_mail(self):
     mail = create(Builder("mail").with_message(MAIL_DATA))
     return mail
Beispiel #15
0
class PythonPackageBuilder(object):
    """The python package builder builds a fully functional python package
    with setup.py, namespace packages and egg-info.
    """

    def __init__(self, session):
        self.session = session
        self.path = None
        self.name = None
        self.version = '1.0.0.dev0'
        self.namespaces = None
        self.package = Builder('subpackage')
        self.directories = []
        self.files = []
        self.profiles = []

    def at_path(self, path):
        """Set the path on the filesystem where the python package should be put,
        usually a temporary directory.
        No subdirectory is created, the ``setup.py`` is written directly
        into this path.
        """
        self.path = Path(path)
        return self

    def named(self, name):
        """Set the dottedname of the package.
        """
        self._validate_package_name(name)
        self.name = name
        self.package.with_i18n_domain(name)
        return self

    def with_version(self, version):
        """Change the package version.
        """
        self.version = version
        return self

    def with_subpackage(self, subpackage_builder):
        """Register a subpackage by passing a "subpackage" builder as argument.
        The subpackage builder should have a name (use .named()),
        the location / path is automatically set.
        """
        self.package.with_subpackage(subpackage_builder)
        return self

    def with_profile(self, profile_builder):
        """Register a generic setup profile for creation.
        """
        self.profiles.append(profile_builder.with_package_name(self.name).within(self.package))
        return self

    def with_root_directory(self, relative_path):
        """Creates a directory relative to the root directory.
        """
        self.directories.append(relative_path)
        return self

    def with_root_file(self, relative_path, contents, makedirs=False):
        """Creates a file relative to the root directory.
        """
        if makedirs and Path(relative_path).parent:
            self.with_root_directory(Path(relative_path).parent)

        self.files.append((relative_path, contents))
        return self

    def with_directory(self, relative_path):
        """Creates a directory relative to the package directory.
        """
        self.package.with_directory(relative_path)
        return self

    def with_file(self, relative_path, contents, makedirs=False):
        """Creates a file relative to the main package directory.
        """
        self.package.with_file(relative_path, contents, makedirs=makedirs)
        return self

    def with_zcml_file(self):
        """Trigger building a ZCML file.
        """
        self.package.with_zcml_file()
        return self

    def with_zcml_include(self, *args, **kwargs):
        """Delegates a ZCML inclusion to the configure.zcml builder.
        """
        self.package.with_zcml_include(*args, **kwargs)
        return self

    def with_zcml_node(self, *args, **kwargs):
        """Delegates a ZCML node declaration to the configure.zcml builder.
        """
        self.package.with_zcml_node(*args, **kwargs)
        return self

    def get_configure_zcml(self):
        """Returns the configure.zcml builder of the package.
        """
        return self.package.get_configure_zcml()

    def create(self):
        assert self.path, 'Use PackageBuilder.at_path(path) to' + \
            ' set a path to create the package in.'
        assert self.name, 'Use PackageBuilder.named(name) to' + \
            ' set the dottedname of the package.'
        self.path.mkdir_p()

        self.package.at_path(self.path.joinpath(*self.name.split('.')))
        self._create_setup()
        self._create_namespaces()
        profile_paths = dict((builder.name, create(builder))
                             for builder in self.profiles)
        package_path = create(self.package)

        for relative_path in self.directories:
            self.path.joinpath(relative_path).makedirs()

        for relative_path, contents in self.files:
            self.path.joinpath(relative_path).write_text(contents)

        self._build_egginfo()
        return Package(self.name, self.path, package_path,
                       profiles=profile_paths)

    def _create_setup(self):
        self.with_root_file('setup.py', SETUP_PY_TEMPLATE.format(
                name=self.name,
                version=self.version,
                namespaces=parent_namespaces(self.name)))

    def _create_namespaces(self):
        for dottedname in parent_namespaces(self.name):
            path = self.path.joinpath(*dottedname.split('.'))
            create(Builder('namespace package').at_path(path))

    def _build_egginfo(self):
        # The current Python (sys.executable) might not have setuptools
        # in its path.
        # For avoiding an error we generate an egginfo_builder script
        # which works around this problem.

        import setuptools
        setuptools_path = Path(setuptools.__file__).dirname().dirname()

        egginfo_builder = self.path.joinpath('egginfo_builder')
        egginfo_builder.write_text(EGGINFO_BUILDER.format(
                executable=sys.executable,
                setuptools_path=setuptools_path))

        try:
            egginfo_builder.chmod(stat.S_IRUSR | stat.S_IXUSR)

            process = subprocess.Popen(egginfo_builder, cwd=str(self.path),
                                       stdout=subprocess.PIPE,
                                       stderr=subprocess.PIPE)
            _, stderrdata = process.communicate()
            assert process.returncode == 0, 'Failed to run "{0}":\n{1}'.format(
                egginfo_builder, stderrdata)

        finally:
            egginfo_builder.remove()

    def _validate_package_name(self, name):
        """For avoiding import collisions package names which are already somehow used
        are not allowed.
        """

        def find_module(dottedname, paths=None):
            # imp.find_module does not support dottednames, it can only
            # resolve one name level at the time.
            # This find_module function does the recursion so that
            # dottednames work.
            if '.' in dottedname:
                name, dottedname = dottedname.split('.', 1)
            else:
                name = dottedname
                dottedname = None

            fp, pathname, description = imp.find_module(name, paths)
            if not dottedname:
                return fp, pathname, description
            else:
                return find_module(dottedname, [pathname])

        try:
            fp, pathname, description = find_module(name)
        except ImportError:
            return True

        else:
            raise ValueError(
                'Invalid package name "{0}": there is already'
                ' a package or module with the same name.'.format(name))
Beispiel #16
0
 def create_item(self):
     return create(Builder('repository').within(self.repository))
Beispiel #17
0
    def setUp(self):
        super(TestReferencePrefixAdapter, self).setUp()

        self.repository = create(Builder('repository').titled(u'Position'))
        self.adapter = IReferenceNumberPrefix(self.repository)
 def setUp(self):
     super(TestContactByline, self).setUp()
     self.contactfolder = create(Builder('contactfolder'))
    def test_decide_an_decided_agenda_item_is_ignored(self):
        item = create(
            Builder('agenda_item').having(title=u'foo', meeting=self.meeting))
        item.decide()

        item.decide()
 def setUp(self):
     super(TestContactFolderTabbedView, self).setUp()
     self.contactfolder = create(Builder('contactfolder')
                                 .titled(u'Kontakte'))
 def folder_builder(self):
     return Builder('dxfolder')
Beispiel #22
0
class TestUpgradeStepBuilder(UpgradeTestCase):

    def setUp(self):
        super(TestUpgradeStepBuilder, self).setUp()
        self.profile = Builder('genericsetup profile')
        self.package.with_profile(self.profile)

    def test_upgrade_step_directory_and_file_is_created(self):
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1))
                                  .named('migrate file content type'))

        with self.package_created() as package:
            upgrade_path = package.package_path.joinpath(
                'upgrades', '20110101000000_migrate_file_content_type')
            self.assertTrue(upgrade_path.isdir(),
                            'Upgrade directory was not created {0}'.format(upgrade_path))
            self.assertMultiLineEqual(
                '\n'.join(('from ftw.upgrade import UpgradeStep',
                           '',
                           '',
                           'class MigrateFileContentType(UpgradeStep):',
                           '    """Migrate file content type.',
                           '    """',
                           '',
                           '    def __call__(self):',
                           '        self.install_upgrade_profile()',
                           '')),
                upgrade_path.joinpath('upgrade.py').text())

    def test_executing_upgrade_step_with_custom_code(self):
        class AddExcludeFromNavIndex(UpgradeStep):
            def __call__(self):
                self.catalog_add_index('excludeFromNav', 'KeywordIndex')

        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1))
                                  .calling(AddExcludeFromNavIndex))

        catalog = getToolByName(self.portal, 'portal_catalog')
        with self.package_created():
            self.install_profile('the.package:default', '0')
            self.assertNotIn('excludeFromNav', catalog.indexes(),
                             'Index excludeFromNav already exists.')
            self.install_profile_upgrades('the.package:default')
            self.assertIn('excludeFromNav', catalog.indexes(),
                          'Index excludeFromNav was not created.')

    def test_add_files_and_directories_to_profile(self):
        self.profile.with_upgrade(
            Builder('ftw upgrade step')
            .to(datetime(2011, 1, 1))
            .with_file('foo.txt', 'FOO')
            .with_directory('bar')
            .with_file('baz/baz.txt', 'BAZ', makedirs=True))

        with self.package_created() as package:
            upgrade_path = package.package_path.joinpath('upgrades',
                                                         '20110101000000_upgrade')
            self.assertTrue(upgrade_path.isdir(),
                            'Upgrade directory was not created {0}'.format(upgrade_path))

            self.assertEqual('FOO', upgrade_path.joinpath('foo.txt').text())
            self.assertTrue(upgrade_path.joinpath('bar').isdir(),
                            'directory "bar" was not created.')
            self.assertEqual('BAZ', upgrade_path.joinpath('baz', 'baz.txt').text())

    def test_importing_upgrade_step_with_import_profile_files(self):
        self.profile.with_upgrade(
            Builder('ftw upgrade step')
            .to(datetime(2011, 1, 1))
            .with_file('properties.xml', self.asset('foo-property.xml')))

        with self.package_created():
            self.install_profile('the.package:default', '0')
            self.assertFalse(self.portal.getProperty('foo'),
                             'Expected property "foo" to not yet exist.')
            self.install_profile_upgrades('the.package:default')
            self.assertEqual('bar',
                             self.portal.getProperty('foo'),
                             'Property "foo" was not created.')
class TestGenericSetupProfileBuilder(TestCase):
    layer = BUILDER_INTEGRATION_TESTING

    def setUp(self):
        self.genericsetup = getToolByName(self.layer["portal"], "portal_setup")
        self.package_builder = Builder("python package").named("the.package").at_path(self.layer["temp_directory"])

    def test_loading_generic_setup_profile(self):
        package = create(self.package_builder.with_profile(Builder("genericsetup profile").named("default")))

        self.assertFalse(self.get_profile_info("the.package:default"))
        with package.zcml_loaded(self.layer["configurationContext"]):
            self.assertTrue(self.get_profile_info("the.package:default"), "Generic setup profile was not loaded.")

    def test_package_infos(self):
        package = create(
            self.package_builder.with_profile(
                Builder("genericsetup profile").titled("The Package").with_fs_version("2003")
            )
        )

        with package.zcml_loaded(self.layer["configurationContext"]):
            self.assertDictContainsSubset(
                {"id": u"the.package:default", "title": u"The Package", "version": u"2003"},
                self.get_profile_info("the.package:default"),
            )

    def test_default_title_is_package_name(self):
        package = create(self.package_builder.with_profile(Builder("genericsetup profile")))

        with package.zcml_loaded(self.layer["configurationContext"]):
            self.assertDictContainsSubset(
                {"id": u"the.package:default", "title": u"the.package"}, self.get_profile_info("the.package:default")
            )

    def test_creating_files_in_the_profile(self):
        package = create(
            self.package_builder.with_profile(
                Builder("genericsetup profile").with_file("catalog.xml", "<object></object>")
            )
        )

        catalog = package.profiles["default"].joinpath("catalog.xml")
        self.assertTrue(catalog.isfile(), "catalog.xml was not created.")
        self.assertEqual("<object></object>", catalog.text())

    def test_creating_directories_in_the_profile(self):
        package = create(
            self.package_builder.with_profile(
                Builder("genericsetup profile")
                .with_directory("workflows")
                .with_file("types/thing.xml", "<object></object>", makedirs=True)
            )
        )

        profile_path = package.profiles["default"]
        self.assertTrue(profile_path.joinpath("workflows").isdir(), 'Directory "workflows" was not created.')

        type_path = profile_path.joinpath("types", "thing.xml")
        self.assertTrue(type_path.isfile(), "types/thing.xml was not created.")
        self.assertEqual("<object></object>", type_path.text())

    def test_dependencies(self):
        package = create(
            self.package_builder.with_profile(
                Builder("genericsetup profile").with_dependencies(
                    "collective.foo:default", "profile-collective.bar:default"
                )
            )
        )

        with package.zcml_loaded(self.layer["configurationContext"]):
            self.assertEquals(
                (u"profile-collective.foo:default", u"profile-collective.bar:default"),
                self.genericsetup.getDependenciesForProfile("the.package:default"),
            )

    def get_profile_info(self, profile_id):
        try:
            return self.genericsetup.getProfileInfo(profile_id)
        except KeyError:
            return None
Beispiel #24
0
    def setUp(self):
        super(TestProtocolJsonData, self).setUp()
        self.root = create(Builder('repository_root'))
        self.folder = create(Builder('repository').titled('Strafwesen'))
        self.dossier = create(
            Builder("dossier").within(self.folder))
        self.doc1 = create(Builder("document")
                           .titled("Beweisaufn\xc3\xa4hme")
                           .within(self.dossier)
                           .attach_file_containing("lorem ipsum",
                                                   name=u"beweisaufna-hme.txt"))
        self.doc2 = create(Builder("document")
                           .titled("Strafbefehl")
                           .within(self.dossier))
        self.mail1 = create(Builder("mail")
                            .titled(u"L\xf6rem")
                            .with_message("lorem", filename=u"lorem.eml"))

        self.proposal = create(
            Builder('proposal_model')
            .having(title=u'Strafbefehl wegen Bauens ohne Bewilligung',
                    initial_position=u'<div>Im Fru\u0308hjahr wurde festgestellt, dass Irgendwer neue Nebenbauten auf einer Liegenschaft erstellt hatte. Auf die mu\u0308ndliche Aufforderung des Ressortvorstehers des Gemeinderates hin reichte er in der Folge ein Baugesuch ein, welches nach Kontrolle durch die Bauverwaltung erga\u0308nzt wurde. Es zeigte sich, dass ein fr\xfcher erstellter Holzschopf durch ein Gartenhaus ersetzt und ein Unterstand fu\u0308r ein Campingfahrzeug an einen fr\xfcher errichteten Holz- und Gera\u0308teschuppen angebaut worden war. Die Baubewilligung konnte nun erteilt werden, wobei die Zustimmung des Departementes Bau, Verkehr und Umwelt eingeholt werden musste, da sich die Bauvorhaben ausserhalb des Baugebietes befinden. Aus dem schriftlich begru\u0308ndeten Nachweis der Notwendigkeit der ausserhalb Baugebiet liegenden Bauten durch den Bauherrn geht hervor, dass das auch als Werkstatt dienende Gartenhaus von seinem in der gleichen Liegenschaft lebenden Sohn erstellt wurde. Er nutzt diese Baute auch.</div>',
                    legal_basis=u'<div>Gegen diesen Strafbefehl k\xf6nnen die Geb\xfcssten innert 20 Tagen seit Er\xf6ffnung beim Gemeinderat schriftlich Einsprache erheben. Die Einsprache hat ein Begehren und eine Begr\xfcndung zu enthalten. In diesem Falle wird eine Einspracheverhandlung vor dem Gemeinderat durchgef\xfchrt, in deren Folge der Gemeinderat einen Entscheid mit Beschwerdem\xf6glichkeit an das Bezirksgericht f\xe4llt.</div>',
                    proposed_action=u'<div>Busse</div>',
                    dossier_reference_number='FD 2.6.8/1',
                    repository_folder_title=u'Strafwesen',
                    considerations=u'<div>Die Bauten sind eindeutig Baubewilligungspflichtig. Gem\xe4ss \xa7 59 des Baugesetzes bed\xfcrfen alle Bauten und ihre im Hinblick auf die Anliegen der Raumplanung, des Umweltschutzes oder der Baupolizei wesentliche Umgestaltung, Erweiterung oder Zweck\xe4nderung sowie die Beseitigung von Geb\xe4uden der Bewilligung durch den Gemeinderat. Das Bauen ohne Baubewilligung stellt eine strafbare Handlung nach \xa7 160 Baugesetz dar. Strafbar ist die vors\xe4tzliche oder fahrl\xe4ssige Widerhandlung, begangen durch Bauherren, Eigent\xfcmer, sonstige Berechtigte, Projektverfasser, Unternehmer und Bauleiter. Im vorliegenden Fall ist der Straftatbestand durch den Bauherrn und seinen Sohn erf\xfcllt. Aus Gr\xfcnden der Gleichbehandlung mit anderen F\xe4llen ist der Gemeinderat gezwungen, die \xdcbertretung angemessen zu bestrafen.</div><ul><li>UL Eintrag</li><li>UL Eintrag<ul><li>UL Einger\xfcckt</li></ul></li></ul>',
                    copy_for_attention=u'<div>Hanspeter</div>',
                    disclose_to=u'<div>Jans\xf6rg</div>',
                    decision_draft=u'<div>Der Gemeinderat erstattet Strafanzeige gegen Unbekannt und informiert zudem den Vermieter (Herr. Meier).</div>',
                    publish_in=u'<div>Tagblatt</div>',)
            .with_submitted_documents(self.doc1, self.doc2, self.mail1))
        self.committee = create(Builder('committee_model')
                                .having(title=u'Gemeinderat'))
        self.member_peter = create(Builder('member'))
        self.member_franz = create(Builder('member')
                                   .having(firstname=u'Franz',
                                           lastname=u'M\xfcller',
                                           email="*****@*****.**"))
        self.member_anna = create(Builder('member')
                                  .having(firstname=u'Anna',
                                          lastname=u'B\xe4nni',
                                          email="*****@*****.**"))
        self.membership_peter = create(Builder('membership').having(
            member=self.member_peter,
            committee=self.committee,
            date_from=date(2010, 1, 1),
            date_to=date(2012, 1, 1),
            role=u'F\xfcrst'))
        self.membership_franz = create(Builder('membership').having(
            member=self.member_franz,
            committee=self.committee,
            date_from=date(2010, 1, 1),
            date_to=date(2012, 1, 1),
            role=None))
        self.membership_anna = create(Builder('membership').having(
            member=self.member_anna,
            committee=self.committee,
            date_from=date(2010, 1, 1),
            date_to=date(2012, 1, 1),
            role=None))
        self.meeting = create(Builder('meeting').having(
            committee=self.committee,
            participants=[self.member_peter,
                          self.member_franz,
                          self.member_anna],
            other_participants=u'Hans M\xfcller\nHeidi Muster',
            protocol_start_page_number=42,
            meeting_number=11,
            presidency=self.member_peter,
            secretary=self.member_franz,))

        self.agend_item_text = create(
            Builder('agenda_item').having(
                title=u'R\xfccktritt Hans Muster',
                meeting=self.meeting,
                discussion=u'<div>Hans Muster tritt als Gemeinderat zur\xfcck.</div>',
                decision=u'<div>Der Gemeinderat hat den R\xfccktritt genehmigt. Die Neuwahl eines Ersatzmitglieds f\xfcr Hans Muster erfolgt bald. Die Wahlvorschl\xe4ge sind n\xe4chstens bei der Kanzlei einzureichen. Falls ein 2. Wahlgang notwendig werden sollte, wird dieser danach durchgef\xfchrt. Die detaillierten Angaben \xfcber den Eingang der Wahlvorschl\xe4ge usw. sind ab sofort auf der Gemeindehomepage publiziert.</div>',
                decision_number=2,))

        self.agenda_item_proposal = create(
            Builder('agenda_item').having(
                proposal=self.proposal,
                meeting=self.meeting,
                decision=u'<div>Die Bauherren werden gest\xfctzt auf \xa7 160 und in Anwendung von \xa7 162 des Baugesetzes wegen Bauens ohne Baubewilligung gesamthaft bestraft. Der Betrag von je Fr. 1000.-- ist - sofern keine Einsprache erfolgt - innert 30 Tagen der Finanzverwaltung der Gemeinde zu bezahlen.</div><ol><li>Erster Punkt</li><li>Zweiter Punkt<ol><li>Subpunkt</li></ol></li></ol>',
                discussion=u'<div>Der Gemeinderat setzt sich geschlossen f\xfcr eine Busse ein.</div>',
                decision_number=1))
class TestDirectoryMetaDirective(UpgradeTestCase):

    def setUp(self):
        super(TestDirectoryMetaDirective, self).setUp()
        self.profile = Builder('genericsetup profile')
        self.package.with_profile(self.profile)

    def test_upgrade_steps_are_registered(self):
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add_action'))
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 2, 2, 8))
                                  .named('remove_action'))

        with self.package_created():
            self.assert_upgrades([
                    {'source': ('10000000000000',),
                     'dest': ('20110101080000',),
                     'title': u'Add action.'},

                    {'source': ('20110101080000',),
                     'dest': ('20110202080000',),
                     'title': u'Remove action.'}])

    def test_first_source_version_is_last_regulare_upgrade_step(self):
        self.profile.with_upgrade(Builder('plone upgrade step')
                                  .upgrading('1000', to='1001')
                                  .titled(u'Register foo utility.'))
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add_action'))

        with self.package_created():
            self.assert_upgrades([
                    {'source': ('1000',),
                     'dest': ('1001',),
                     'title': u'Register foo utility.'},

                    {'source': ('1001',),
                     'dest': ('20110101080000',),
                     'title': u'Add action.'}])

    def test_registers_migration_generic_setup_profile_foreach_step(self):
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add_an_action'))

        with self.package_created() as package:
            upgrade_path = package.package_path.joinpath(
                'upgrades', '20110101080000_add_an_action')
            self.assert_profile(
                {'id': 'the.package.upgrades:default-upgrade-20110101080000',
                 'title': 'Upgrade the.package:default ' + \
                     'to 20110101080000: Add an action.',
                 'description': '',
                 'path': upgrade_path,
                 'product': 'the.package.upgrades',
                 'type': EXTENSION,
                 'for': IMigratingPloneSiteRoot})

    def test_package_modules_is_not_corrupted(self):
        # Regression: when the upgrade-step:directory directive is used from
        # the package-directory with a relative path (directory="upgrades"),
        # it corrupted the sys.modules entry of the package.

        package_builder = (
            Builder('python package')
            .named('other.package')
            .at_path(self.layer['temp_directory'])
            .with_file('__init__.py', 'PACKAGE = "package root"')

            .with_directory('profiles/default')
            .with_zcml_node('genericsetup:registerProfile',
                            name='default',
                            title='other.package:default',
                            directory='profiles/default',
                            provides='Products.GenericSetup.interfaces.EXTENSION')

            .with_directory('upgrades')
            .with_file('upgrades/__init__.py', 'PACKAGE = "upgrades package"')
            .with_zcml_include('ftw.upgrade', file='meta.zcml')
            .with_zcml_node('upgrade-step:directory',
                            profile='other.package:default',
                            directory='upgrades'))

        with create(package_builder).zcml_loaded(self.layer['configurationContext']):
            import other.package
            self.assertEquals('package root', other.package.PACKAGE)

    def test_profile_must_be_registed_before_registering_upgrade_directory(self):
        package_builder = (Builder('python package')
                           .named('other.package')
                           .at_path(self.layer['temp_directory'])
                           .with_zcml_include('ftw.upgrade', file='meta.zcml')
                           .with_zcml_node('upgrade-step:directory',
                                           profile='other.package:default',
                                           directory='.'))

        with create(package_builder) as package:
            with self.assertRaises(ConfigurationExecutionError) as cm:
                package.load_zcml(self.layer['configurationContext'])

        self.assertEqual(
            "<class 'ftw.upgrade.exceptions.UpgradeStepConfigurationError'>: "
            'The profile "other.package:default" needs to be registered'
            ' before registering its upgrade step directory.',
            str(cm.exception).splitlines()[0])

    def test_profile_version_is_set_to_latest_profile_version(self):
        self.profile.with_upgrade(Builder('ftw upgrade step').to(datetime(2011, 1, 1, 8)))
        self.profile.with_upgrade(Builder('ftw upgrade step').to(datetime(2011, 2, 2, 8)))

        with self.package_created() as package:
            profile_path = package.package_path.joinpath('profiles', 'default')
            self.assert_profile(
                {'id': u'the.package:default',
                 'title': u'the.package',
                 'description': u'',
                 'ftw.upgrade:dependencies': None,
                 'path': profile_path,
                 'version': '20110202080000',
                 'product': 'the.package',
                 'type': EXTENSION,
                 'for': None})

    def test_profile_version_is_set_to_latest_old_school_profile_version(self):
        self.profile.with_upgrade(Builder('plone upgrade step')
                                  .upgrading('1000', to='1001')
                                  .titled(u'Register foo utility.'))
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 2, 2, 8)))

        package = create(self.package)
        # Remove upgrade-step directory upgrade in order to have the
        # manually created upgrade step as last version
        # but still declaring an upgrade-step:directory:
        package.package_path.joinpath(
            'upgrades', '20110202080000_upgrade').rmtree()

        profile_path = package.package_path.joinpath('profiles', 'default')
        self.assertNotIn('<version',
                         profile_path.joinpath('metadata.xml').text())

        with package.zcml_loaded(self.layer['configurationContext']):
            from ftw.upgrade.directory.zcml import find_start_version
            find_start_version(u'the.package:default')
            self.assert_profile(
                {'id': u'the.package:default',
                 'title': u'the.package',
                 'description': u'',
                 'ftw.upgrade:dependencies': None,
                 'path': str(profile_path),
                 'version': '1001',
                 'product': 'the.package',
                 'type': EXTENSION,
                 'for': None})

    def test_version_set_to_default_when_no_upgrades_defined(self):
        upgrades = self.package.package.get_subpackage('upgrades')
        upgrades.with_zcml_include('ftw.upgrade', file='meta.zcml')
        upgrades.with_zcml_node('upgrade-step:directory',
                                profile='the.package:default',
                                directory='.')

        with self.package_created() as package:
            profile_path = package.package_path.joinpath('profiles', 'default')
            self.assert_profile(
                {'id': u'the.package:default',
                 'title': u'the.package',
                 'description': u'',
                 'ftw.upgrade:dependencies': None,
                 'path': profile_path,
                 'version': u'10000000000000',
                 'product': 'the.package',
                 'type': EXTENSION,
                 'for': None})

    def test_profile_must_not_have_a_metadata_version_defined(self):
        self.profile.with_fs_version('1000')
        self.profile.with_upgrade(Builder('ftw upgrade step').to(datetime(2011, 1, 1, 8)))

        with create(self.package) as package:
            with self.assertRaises(ConfigurationExecutionError) as cm:
                package.load_zcml(self.layer['configurationContext'])

        self.assertEqual(
            "<class 'ftw.upgrade.exceptions.UpgradeStepConfigurationError'>: "
            'Registering an upgrades directory for "the.package:default" requires'
            ' this profile to not define a version in its metadata.xml.'
            ' The version is automatically set to the latest upgrade.',
            str(cm.exception).splitlines()[0])

    def test_declaring_upgrades_dependency(self):
        self.package.with_profile(
            Builder('genericsetup profile')
            .named('bar')
            .with_upgrade(
                Builder('ftw upgrade step')
                .to(datetime(2010, 1, 1, 1, 1))
                .with_zcml_directory_options(
                    soft_dependencies="the.package:baz")))

        self.package.with_profile(
            Builder('genericsetup profile')
            .named('foo')
            .with_upgrade(
                Builder('ftw upgrade step')
                .to(datetime(2010, 1, 1, 1, 1))
                .with_zcml_directory_options(
                    soft_dependencies="the.package:bar the.package:baz")))

        self.package.with_profile(
            Builder('genericsetup profile')
            .named('baz')
            .with_upgrade(
                Builder('ftw upgrade step')
                .to(datetime(2010, 1, 1, 1, 1))
                .with_zcml_directory_options(
                    soft_dependencies="the.package:default")))

        with self.package_created() as package:
            self.assert_profile(
                {'id': u'the.package:foo',
                 'title': u'the.package',
                 'description': u'',
                 'ftw.upgrade:dependencies': [u'the.package:bar',
                                              u'the.package:baz'],
                 'path': package.package_path.joinpath('profiles', 'foo'),
                 'version': u'20100101010100',
                 'product': 'the.package',
                 'type': EXTENSION,
                 'for': None})

            portal_setup = getToolByName(self.portal, 'portal_setup')
            self.assertEquals(
                [u'the.package:default',
                 u'the.package:baz',
                 u'the.package:bar',
                 u'the.package:foo'],
                filter(lambda profile_id: profile_id.startswith('the.package:'),
                       get_sorted_profile_ids(portal_setup)))

    def test_handler_step_provides_interfaces_implemented_by_upgrade_step_class(self):
        code = '\n'.join((
            'from ftw.upgrade import UpgradeStep',
            'from ftw.upgrade.tests.test_directory_meta_directive import IFoo',
            'from zope.interface import implementer',
            '',
            '@implementer(IFoo)',
            'class Foo(UpgradeStep):',
            '    pass'))

        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 1))
                                  .with_code(code))

        with self.package_created():
            portal_setup = getToolByName(self.portal, 'portal_setup')
            steps = listUpgradeSteps(portal_setup, 'the.package:default', '10000000000000')
            self.assertEquals(1, len(steps))
            self.assertItemsEqual(
                (IRecordableHandler,
                 IUpgradeStep,
                 IFoo),
                tuple(providedBy(steps[0]['step'].handler)))
            self.assertTrue(steps[0]['step'].handler.handler)

    def assert_upgrades(self, expected):
        upgrades = self.portal_setup.listUpgrades('the.package:default')
        got = [dict((key, value) for (key, value) in step.items()
                    if key in ('source', 'dest', 'title'))
               for step in upgrades]
        self.maxDiff = None
        self.assertItemsEqual(expected, got)

    def assert_profile(self, expected):
        self.assertTrue(
            self.portal_setup.profileExists(expected['id']),
            'Profile "{0}" does not exist. Profiles: {1}'.format(
                expected['id'],
                [profile['id'] for profile in self.portal_setup.listProfileInfo()]))

        got = self.portal_setup.getProfileInfo(expected['id']).copy()

        # Ignore pre_handler and post_handler, only available in Plone >= 4.3.8
        got.pop('pre_handler', None)
        got.pop('post_handler', None)

        self.maxDiff = None
        self.assertDictEqual(expected, got)
    def setUp(self):
        super(TestFileOrPaperValidatorInEditForm, self).setUp()

        self.dossier = create(Builder('dossier'))
        self.mail = create(
            Builder('mail').within(self.dossier).with_dummy_message())
Beispiel #27
0
class SubPackageBuilder(object):
    """The subpackage builder builds the deepest level of a python package.
    It may build a configure.zcml and can manage nested subpackages.

    The filesystem path of the subpackage is either defined by setting
    a name (with ``.named('name')``) and a parent package
    (using ``.within(parent_package)``)
    or by explicitly setting the path (with ``.at_path(path)``)
    """

    def __init__(self, session):
        self.session = session
        self.name = None
        self.parent_package = None
        self.path = None
        self.configure_zcml = None
        self.i18n_domain = None
        self.subpackages = []
        self.directories = []
        self.files = [('__init__.py', '')]

    def named(self, name):
        """The last part of the dottedname representing this subpackage.
        E.g. when building a browser subpackage, the name is just "browser".
        """
        if self.path:
            raise ValueError('Using .at_path() and .named() / .within()'
                             ' for the same builder is not allowed.')

        self.name = name
        return self

    def within(self, parent_package):
        """Register a parent package.
        """
        if self.path:
            raise ValueError('Using .at_path() and .named() / .within()'
                             ' for the same builder is not allowed.')

        self.parent_package = parent_package
        return self

    def at_path(self, path):
        """Set the absolute filesystem path for the subpackage.
        """
        if self.path or self.parent_package:
            raise ValueError('Using .at_path() and .named() / .within()'
                             ' for the same builder is not allowed.')

        self.path = Path(path)
        return self

    def with_subpackage(self, subpackage_builder):
        """Nest another subpackage builder within this subpackage.
        Nested subpackages will automatically be created when
        this package is created.
        """
        subpackage_builder.within(self)
        self.subpackages.append(subpackage_builder)
        return self

    def get_subpackage(self, name):
        """Returns a nested subpackage builder with a specific name.
        If there is already a builder with this name, the existing
        builder is returned.
        """
        for subbuilder in self.subpackages:
            if subbuilder.name == name:
                return subbuilder
        subbuilder = Builder('subpackage').named(name)
        self.with_subpackage(subbuilder)
        return subbuilder

    def with_i18n_domain(self, domain):
        """Set the i18n-domain for the ZCML file.
        This does not trigger ZCML file creation.
        """
        self.i18n_domain = domain
        return self

    def with_zcml_file(self):
        """Trigger creating a configure.zcml.
        """
        self.get_configure_zcml()
        return self

    def with_directory(self, relative_path):
        """Create a directory relative to the package directory.
        """
        self.directories.append(relative_path)
        return self

    def with_file(self, relative_path, contents, makedirs=False):
        """Create a file within this package.
        """
        if makedirs and Path(relative_path).parent:
            self.with_directory(Path(relative_path).parent)

        self.files.append((relative_path, contents))
        return self

    def with_zcml_include(self, *args, **kwargs):
        """Delegates a ZCML inclusion to the configure.zcml builder.
        """
        self.get_configure_zcml().include(*args, **kwargs)
        return self

    def with_zcml_node(self, *args, **kwargs):
        """Delegates a ZCML node declaration to the configure.zcml builder.
        """
        self.get_configure_zcml().with_node(*args, **kwargs)
        return self

    def get_configure_zcml(self):
        """Returns the configure.zcml builder.
        """
        if self.configure_zcml is not None:
            return self.configure_zcml

        self.configure_zcml = Builder('zcml')
        return self.configure_zcml

    def create(self):
        if not self.path:
            if not self.parent_package or not self.name:
                raise ValueError('Unknown target: use either .at_path()'
                                 ' or .named() and .within()')
            self.path = self.parent_package.path.joinpath(self.name)

        self.path.mkdir_p()
        map(create, self.subpackages)

        for relative_path in self.directories:
            self.path.joinpath(relative_path).makedirs()

        for relative_path, contents in self.files:
            self.path.joinpath(relative_path).write_text(contents)

        if self.configure_zcml is not None:
            if self.i18n_domain:
                self.configure_zcml.with_i18n_domain(self.i18n_domain)
            self.configure_zcml.at_path(self.path.joinpath('configure.zcml'))
            self.configure_zcml.create()

            if self.parent_package:
                self.parent_package.get_configure_zcml().include(
                    self.configure_zcml)

        return self.path
    def test_is_issuer(self):
        task1 = create(Builder('task').having(issuer=TEST_USER_ID))
        task2 = create(Builder('task').having(issuer='hugo.boss'))

        self.assertTrue(get_checker(task1).current_user.is_issuer)
        self.assertFalse(get_checker(task2).current_user.is_issuer)
class TestDirectoryMetaDirective(UpgradeTestCase):

    def setUp(self):
        super(TestDirectoryMetaDirective, self).setUp()
        self.profile = Builder('genericsetup profile')
        self.package.with_profile(self.profile)

    def test_upgrade_steps_are_registered(self):
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add_action'))
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 2, 2, 8))
                                  .named('remove_action'))

        with self.package_created():
            self.assert_upgrades([
                    {'source': ('10000000000000',),
                     'dest': ('20110101080000',),
                     'title': u'Add action.'},

                    {'source': ('20110101080000',),
                     'dest': ('20110202080000',),
                     'title': u'Remove action.'}])

    def test_first_source_version_is_last_regulare_upgrade_step(self):
        self.profile.with_upgrade(Builder('plone upgrade step')
                                  .upgrading('1000', to='1001')
                                  .titled('Register foo utility.'))
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add_action'))

        with self.package_created():
            self.assert_upgrades([
                    {'source': ('1000',),
                     'dest': ('1001',),
                     'title': u'Register foo utility.'},

                    {'source': ('1001',),
                     'dest': ('20110101080000',),
                     'title': u'Add action.'}])

    def test_registers_migration_generic_setup_profile_foreach_step(self):
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add_an_action'))

        with self.package_created() as package:
            upgrade_path = package.package_path.joinpath(
                'upgrades', '20110101080000_add_an_action')
            self.assert_profile(
                {'id': 'the.package.upgrades:default-upgrade-20110101080000',
                 'title': 'Upgrade the.package:default ' + \
                     'to 20110101080000: Add an action.',
                 'description': '',
                 'path': upgrade_path,
                 'product': 'the.package.upgrades',
                 'type': EXTENSION,
                 'for': IMigratingPloneSiteRoot})

    def test_package_modules_is_not_corrupted(self):
        # Regression: when the upgrade-step:directory directive is used from
        # the package-directory with a relative path (directory="upgrades"),
        # it corrupted the sys.modules entry of the package.

        package_builder = (
            Builder('python package')
            .named('other.package')
            .at_path(self.layer['temp_directory'])
            .with_file('__init__.py', 'PACKAGE = "package root"')

            .with_directory('profiles/default')
            .with_zcml_node('genericsetup:registerProfile',
                            name='default',
                            title='other.package:default',
                            directory='profiles/default',
                            provides='Products.GenericSetup.interfaces.EXTENSION')

            .with_directory('upgrades')
            .with_file('upgrades/__init__.py', 'PACKAGE = "upgrades package"')
            .with_zcml_include('ftw.upgrade', file='meta.zcml')
            .with_zcml_node('upgrade-step:directory',
                            profile='other.package:default',
                            directory='upgrades'))

        with create(package_builder).zcml_loaded(self.layer['configurationContext']):
            import other.package
            self.assertEquals('package root', other.package.PACKAGE)

    def test_profile_must_be_registed_before_registering_upgrade_directory(self):
        package_builder = (Builder('python package')
                           .named('other.package')
                           .at_path(self.layer['temp_directory'])
                           .with_zcml_include('ftw.upgrade', file='meta.zcml')
                           .with_zcml_node('upgrade-step:directory',
                                           profile='other.package:default',
                                           directory='.'))

        with create(package_builder) as package:
            with self.assertRaises(ConfigurationExecutionError) as cm:
                package.load_zcml(self.layer['configurationContext'])

        self.assertEqual(
            "<class 'ftw.upgrade.exceptions.UpgradeStepConfigurationError'>: "
            'The profile "other.package:default" needs to be registered'
            ' before registering its upgrade step directory.',
            str(cm.exception).splitlines()[0])

    def test_profile_version_is_set_to_latest_profile_version(self):
        self.profile.with_upgrade(Builder('ftw upgrade step').to(datetime(2011, 1, 1, 8)))
        self.profile.with_upgrade(Builder('ftw upgrade step').to(datetime(2011, 2, 2, 8)))

        with self.package_created() as package:
            profile_path = package.package_path.joinpath('profiles', 'default')
            self.assert_profile(
                {'id': u'the.package:default',
                 'title': u'the.package',
                 'description': u'',
                 'path': profile_path,
                 'version': '20110202080000',
                 'product': 'the.package',
                 'type': EXTENSION,
                 'for': None})

    def test_version_set_to_default_when_no_upgrades_defined(self):
        upgrades = self.package.package.get_subpackage('upgrades')
        upgrades.with_zcml_include('ftw.upgrade', file='meta.zcml')
        upgrades.with_zcml_node('upgrade-step:directory',
                                profile='the.package:default',
                                directory='.')

        with self.package_created() as package:
            profile_path = package.package_path.joinpath('profiles', 'default')
            self.assert_profile(
                {'id': u'the.package:default',
                 'title': u'the.package',
                 'description': u'',
                 'path': profile_path,
                 'version': u'10000000000000',
                 'product': 'the.package',
                 'type': EXTENSION,
                 'for': None})

    def test_profile_must_not_have_a_metadata_version_defined(self):
        self.profile.with_fs_version('1000')
        self.profile.with_upgrade(Builder('ftw upgrade step').to(datetime(2011, 1, 1, 8)))

        with create(self.package) as package:
            with self.assertRaises(ConfigurationExecutionError) as cm:
                package.load_zcml(self.layer['configurationContext'])

        self.assertEqual(
            "<class 'ftw.upgrade.exceptions.UpgradeStepConfigurationError'>: "
            'Registering an upgrades directory for "the.package:default" requires'
            ' this profile to not define a version in its metadata.xml.'
            ' The version is automatically set to the latest upgrade.',
            str(cm.exception).splitlines()[0])

    def assert_upgrades(self, expected):
        upgrades = self.portal_setup.listUpgrades('the.package:default')
        got = [dict((key, value) for (key, value) in step.items()
                    if key in ('source', 'dest', 'title'))
               for step in upgrades]
        self.maxDiff = None
        self.assertItemsEqual(expected, got)

    def assert_profile(self, expected):
        self.assertTrue(
            self.portal_setup.profileExists(expected['id']),
            'Profile "{0}" does not exist. Profiles: {1}'.format(
                expected['id'],
                [profile['id'] for profile in self.portal_setup.listProfileInfo()]))

        got = self.portal_setup.getProfileInfo(expected['id'])
        self.maxDiff = None
        self.assertDictEqual(expected, got)
    def test_is_responsible(self):
        task1 = create(Builder('task').having(responsible=TEST_USER_ID))
        task2 = create(Builder('task').having(responsible='hugo.boss'))

        self.assertTrue(get_checker(task1).current_user.is_responsible)
        self.assertFalse(get_checker(task2).current_user.is_responsible)
 def test_getting_subpackage_builder(self):
     builder = Builder('subpackage')
     self.assertEquals(builder.get_subpackage('browser'),
                       builder.get_subpackage('browser'),
                       '.get_subpackage() does not always return the same builder'
                       ' for the same name.')
    def test_all_subtasks_is_NOT_finished_when_cancelled_or_resolved(self):
        task = create(Builder('task').in_state('task-state-in-progress'))
        create(Builder('task').within(task).in_state('task-state-resolved'))
        create(Builder('task').within(task).in_state('task-state-cancelled'))

        self.assertFalse(get_checker(task).task.all_subtasks_finished)
Beispiel #33
0
 def before_create(self):
     super(ShopItemBuilder, self).before_create()
     if not IShopCategory.providedBy(self.container):
         self.container = create(Builder('shop category'))
    def test_all_subtasks_finished_is_allways_true_when_no_subtask_exists(
            self):
        task = create(Builder('task').in_state('task-state-in-progress'))

        self.assertTrue(get_checker(task).task.all_subtasks_finished)
Beispiel #35
0
    def test_decide_is_not_possible_for_paragraphs(self):
        item = create(Builder('agenda_item')
                      .having(is_paragraph=True, meeting=self.meeting))

        self.assertFalse(item.is_decide_possible())
Beispiel #36
0
 def test_dossier_is_sendable(self):
     dossier = create(Builder("dossier"))
     self.assertTrue(ISendableDocsContainer.providedBy(dossier))
Beispiel #37
0
    def test_is_decided_is_true_if_the_agendatiem_is_decided(self):
        agenda_item = create(Builder('agenda_item')
                             .having(title=u'Simple', meeting=self.meeting))

        agenda_item.workflow_state = 'decided'
        self.assertTrue(agenda_item.is_decided())
Beispiel #38
0
 def test_user_WITHOUT_modify_permission_in_open_state_CANNOT_edit(self):
     user = create(Builder('user').with_roles('Contributor'))
     self.assertFalse(self.can_edit(user, self.document))
Beispiel #39
0
 def setUp(self):
     super(TestUpgradeStepBuilder, self).setUp()
     self.profile = Builder('genericsetup profile')
     self.package.with_profile(self.profile)
Beispiel #40
0
    def setUp(self):
        super(TestEditPublicTrialForm, self).setUp()

        dossier = create(Builder('dossier').in_state('dossier-state-resolved'))
        self.document = create(
            Builder('document').with_dummy_content().within(dossier))
 def setUp(self):
     self.genericsetup = getToolByName(self.layer["portal"], "portal_setup")
     self.package_builder = Builder("python package").named("the.package").at_path(self.layer["temp_directory"])
Beispiel #42
0
    def test_raise_aunauthorized_if_the_user_CANNOT_modify(self, browser):
        user = create(Builder('user').with_roles('Contributor'))

        with browser.expect_unauthorized():
            browser.login(user.getId()).visit(self.document,
                                              view='edit_public_trial')
 def create_mail_quickupload(self):
     dossier = create(Builder("dossier"))
     mail = create(Builder('quickuploaded_mail')
                   .within(dossier)
                   .with_message(MAIL_DATA))
     return mail
Beispiel #44
0
    def setUp(self):
        super(TestProposalHistory, self).setUp()
        self.admin_unit.public_url = 'http://nohost/plone'
        self.repo, self.repo_folder = create(Builder('repository_tree'))
        self.dossier = create(Builder('dossier').within(self.repo_folder))
        self.meeting_dossier = create(
            Builder('meeting_dossier').within(self.repo_folder))
        self.excerpt_template = create(
            Builder('sablontemplate').with_asset_file('excerpt_template.docx'))
        container = create(
            Builder('committee_container').having(
                excerpt_template=self.excerpt_template))
        self.committee = create(Builder('committee').within(container))
        self.meeting = create(
            Builder('meeting').having(
                committee=self.committee.load_model()).link_with(
                    self.meeting_dossier))

        self.repo, self.repo_folder = create(Builder('repository_tree'))
        self.dossier = create(Builder('dossier').within(self.repo_folder))
        self.document = create(
            Builder('document').within(self.dossier).titled('A Document'))
        self.proposal = create(
            Builder('proposal').within(self.dossier).having(
                title='Mach doch',
                committee=self.committee.load_model()).relate_to(
                    self.document))
 def setUp(self):
     super(TestDirectoryMetaDirective, self).setUp()
     self.profile = Builder('genericsetup profile')
     self.package.with_profile(self.profile)
    def test_document_draft_state_is_initial_state(self):
        doc = create(Builder('document'))

        self.assertEquals(Document.active_state,
                          api.content.get_state(obj=doc))
class TestDirectoryScanner(UpgradeTestCase):

    def setUp(self):
        super(TestDirectoryScanner, self).setUp()
        self.profile = Builder('genericsetup profile')
        self.package.with_profile(self.profile)

    def test_returns_chained_upgrade_infos(self):
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add an action'))
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 2, 2, 8))
                                  .named('update the action'))
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 3, 3, 8))
                                  .named('remove the action'))

        with self.scanned() as upgrade_infos:
            map(lambda info: (info.__delitem__('path'),
                              info.__delitem__('callable')),
                upgrade_infos)

            self.maxDiff = None
            self.assertEqual(
                [{'source-version': None,
                  'target-version': '20110101080000',
                  'title': 'Add an action.'},

                 {'source-version': '20110101080000',
                  'target-version': '20110202080000',
                  'title': 'Update the action.'},

                 {'source-version': '20110202080000',
                  'target-version': '20110303080000',
                  'title': 'Remove the action.'}],

                upgrade_infos)

    def test_exception_raised_when_upgrade_has_no_code(self):
        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add action')
                                  .with_code(''))

        with create(self.package) as package:
            with self.assertRaises(UpgradeStepDefinitionError) as cm:
                self.scan(package)

        self.assertEqual(
            'The upgrade step 20110101080000_add_action has no upgrade class'
            ' in the upgrade.py module.',
            str(cm.exception))

    def test_exception_raised_when_multiple_upgrade_steps_detected(self):
        code = '\n'.join((
                'from ftw.upgrade import UpgradeStep',
                'class Foo(UpgradeStep): pass',
                'class Bar(UpgradeStep): pass'))

        self.profile.with_upgrade(Builder('ftw upgrade step')
                                  .to(datetime(2011, 1, 1, 8))
                                  .named('add action')
                                  .with_code(code))

        with create(self.package) as package:
            with self.assertRaises(UpgradeStepDefinitionError) as cm:
                self.scan(package)

        self.assertEqual(
            'The upgrade step 20110101080000_add_action has more than one upgrade'
            ' class in the upgrade.py module.',
            str(cm.exception))

    def test_does_not_fail_when_no_upgrades_present(self):
        self.package.with_zcml_include('ftw.upgrade', file='meta.zcml')
        self.package.with_zcml_node('upgrade-step:directory',
                                    profile='the.package:default',
                                    directory='.')

        with self.scanned() as upgrade_infos:
            self.assertEqual( [], upgrade_infos)

    @contextmanager
    def scanned(self):
        with create(self.package) as package:
            yield self.scan(package)

    def scan(self, package):
        upgrades = package.package_path.joinpath('upgrades')
        return Scanner('the.package.upgrades', upgrades).scan()
    def test_deleting_document_is_only_allowed_for_managers(self):
        doc = create(Builder('document'))

        with self.assertRaises(Unauthorized):
            api.content.delete(obj=doc)
 def setUp(self):
     self.contributor = create(Builder('user').with_roles('Contributor'))
     self.parent = create(self.folder_builder())
     self.child = create(self.folder_builder().within(self.parent))
 def create_mail_inbound(self):
     dossier = create(Builder("dossier"))
     mail = inbound.createMailInContainer(dossier, MAIL_DATA)
     return mail