def test_slider_pane_cannot_have_link_and_external_url(self, browser):
"""
This test makes sure that the slider pane cannot have a link
and an external url at the same time.
"""
folder = create(Builder('folder').titled(u'Folder'))
container = create(Builder('slider container')
.within(folder)
.titled(u'Slider Container'))
pane = create(Builder('slider pane')
.within(container)
.titled(u'Pane 1')
.with_dummy_image())
my_folder = create(Builder('folder').titled(u'My Folder'))
browser.login().visit(pane)
browser.find('Edit').click()
browser.fill({
'Link': my_folder,
'External URL': 'http://4teamwork.ch',
})
browser.find_button_by_label('Save').click()
assert_message('There were some errors.')
def test_statusmap_on_inactive_content(self, browser):
inactive_folder = create(Builder('folder')
.titled('Inactive Folder')
.having(effectiveDate=DateTime() + 10)
.within(self.portal))
create(Builder('folder')
.titled('Active Folder')
.within(inactive_folder))
# A user not having the permission to access inactive content must
# be able to change the state of the inactive content itself, i.e.
# calling the statusmap view on an inactive context.
setRoles(self.portal, TEST_USER_ID, ['Contributor'])
transaction.commit()
browser.login().visit(inactive_folder, view="@@statusmap")
self.assertEqual(
['Inactive Folder', 'Active Folder'],
browser.css('.listing tr td span').text
)
# The same applies to a user having the permission to access inactive
# content.
setRoles(self.portal, TEST_USER_ID, ['Manager'])
transaction.commit()
browser.login().visit(inactive_folder, view="@@statusmap")
self.assertEqual(
['Inactive Folder', 'Active Folder'],
browser.css('.listing tr td span').text
)
def test_event_archive_portlet_renders_custom_title(self, browser):
event_folder = create(Builder('event folder'))
create(Builder('event page')
.within(event_folder)
.having(startDate=DateTime(2014, 2, 2))
.having(endDate=DateTime(2014, 2, 6)))
create(Builder('event archive portlet').within(event_folder))
browser.login()
# Make sure the portlet renders the default title.
browser.visit(event_folder)
self.assertEqual(
['Events'],
browser.css('dl.portletArchiveListing dt').text
)
# Now let's change the title of the portlet.
browser.visit(event_folder, view='@@manage-portlets')
browser.find('Event Archive Portlet').click()
browser.fill({'Title': u'Foobar'}).submit()
# Make sure the portlet renders the custom title.
browser.visit(event_folder)
self.assertEqual(
['Foobar'],
browser.css('dl.portletArchiveListing dt').text
)
def setUp(self):
super(TestSablonTemplateView, self).setUp()
self.templates = create(Builder('templatefolder'))
self.sablon_template = create(
Builder('sablontemplate')
.within(self.templates)
.with_asset_file('sablon_template.docx'))
def test_statusmap_on_objects_having_inactive_content(self, browser):
# Create a container which will hold the content used for this test.
# The container does not play an important role in the test.
folder = create(Builder('folder').titled('Container'))
# Create some content used in this test.
create(Builder('folder')
.titled('Active Folder')
.within(folder))
create(Builder('folder')
.titled('Inactive Folder')
.having(effectiveDate=DateTime() + 10)
.within(folder))
# A user not having the permission to access inactive content can only
# change the state of the container and the active folder inside the
# container, but not the inactive folder inside the container.
# Thus the inactive folder must not be visible in the statusmap view.
setRoles(self.portal, TEST_USER_ID, ['Contributor'])
transaction.commit()
browser.login().visit(folder, view="@@statusmap")
self.assertEqual(
['Container', 'Active Folder'],
browser.css('.listing tr td span').text
)
# A manager can also change the state of the inactive folder.
# Thus the inactive folder must be visible in the statusmap view too.
setRoles(self.portal, TEST_USER_ID, ['Manager'])
transaction.commit()
browser.login().visit(folder, view="@@statusmap")
self.assertEqual(
['Container', 'Active Folder', 'Inactive Folder'],
browser.css('.listing tr td span').text
)
def setUp(self):
super(TestVersionsTabForDocumentWithoutInitialVersion, self).setUp()
self.dossier = create(Builder('dossier').titled(u'Testdossier'))
self.document = create(Builder('document')
.with_creation_date(DateTime(2016, 11, 6))
.with_dummy_content())
def test_object_added_increases_usage(self):
folder = create(Builder('folder'))
self.assertEquals(0, folder.getField('usage').get(folder))
create(Builder('file')
.within(folder)
.attach_file_containing(' ' * 10))
self.assertEquals(10, folder.getField('usage').get(folder))
def test_category_index_umlauts(self):
catalog = getToolByName(self.portal, "portal_catalog")
create(Builder("sample").having(content_categories=(u"WITH unicode \xe4",)))
unique_values = catalog.Indexes["getContentCategories"].uniqueValues()
self.assertIn("WITH unicode \xc3\xa4", unique_values)
def test_icon_class_of_favorites_get_updated_on_checkout(self):
self.login(self.administrator)
fav_admin = create(Builder('favorite')
.for_object(self.document)
.for_user(self.administrator))
fav_user = create(Builder('favorite')
.for_object(self.document)
.for_user(self.regular_user))
# Show default document icons
with self.login(self.administrator):
self.assertEqual('icon-docx', fav_admin.icon_class)
with self.login(self.regular_user):
self.assertEqual('icon-docx', fav_user.icon_class)
# Checkout document with regular_user
with self.login(self.regular_user):
self.checkout_document(self.document)
# Show checkout-icon for document with administartor
with self.login(self.administrator):
self.assertEqual('icon-docx is-checked-out', fav_admin.icon_class)
# Show self-checkout-icon for document with regular user
with self.login(self.regular_user):
self.assertEqual(
'icon-docx is-checked-out-by-current-user',
fav_user.icon_class)
def test_assign_task_only_to_users_of_the_current_orgunit(self, browser):
self.login(self.regular_user, browser=browser)
org_unit2 = create(Builder('org_unit')
.id('afi')
.having(title=u'Finanzdirektion',
admin_unit_id='fa')
.with_default_groups())
self.hans = create(Builder('ogds_user')
.id('james.bond')
.having(firstname=u'James', lastname=u'Bond')
.assign_to_org_units([org_unit2]))
data = {'form.widgets.transition': 'task-transition-reassign'}
browser.open(self.task, data, view='assign-task')
browser.open(self.task,
data={'q': 'james', 'page': 1},
view='@@assign-task/++widget++form.widgets.responsible/search')
self.assertEquals([], browser.json.get('results'))
browser.open(self.task,
data={'q': 'robert', 'page': 1},
view='@@assign-task/++widget++form.widgets.responsible/search')
self.assertEquals(
[{u'_resultId': u'fa:robert.ziegler',
u'id': u'fa:robert.ziegler',
u'text': u'Finanzamt: Ziegler Robert (robert.ziegler)'}],
browser.json.get('results'))
def test_activate_placeful_workflow_policy_with_mapping(self):
container = create(Builder('folder')
.titled('Container')
.in_state('external'))
subfolder = create(Builder('folder')
.within(container)
.titled('Subfolder')
.in_state('pending'))
document = create(Builder('document')
.within(subfolder)
.titled('The Document')
.in_state('internally_published'))
self.create_placeful_workflow_policy(
named='local_workflow',
with_workflows={
'Folder': 'plone_workflow'})
activator = PlacefulWorkflowPolicyActivator(container)
activator.activate_policy(
'local_workflow',
review_state_mapping={
('intranet_workflow', 'plone_workflow'): {
'external': 'published',
'pending': 'pending'}})
self.assertReviewStates({
container: 'published',
subfolder: 'pending',
document: 'internally_published'})
def test_returns_none_if_no_mimetype_is_available(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
adapter = getMultiAdapter((document, self.request), IBumblebeeOverlay)
self.assertIsNone(adapter.get_open_as_pdf_url())
def test_journal_and_task_pdfs_are_not_listed(self, browser):
self.activate_feature('tasks-pdf')
self.activate_feature('journal-pdf')
self.login(self.secretariat_user, browser)
create(Builder('task')
.within(self.empty_dossier)
.titled(u'Arbeitsentwurf checken')
.having(responsible_client='fa',
responsible=self.secretariat_user.getId(),
issuer=self.dossier_responsible.getId(),
task_type='correction',
deadline=date(2016, 11, 1))
.in_state('task-state-tested-and-closed'))
with freeze(datetime(2018, 4, 30)):
self.resolve(self.empty_dossier, browser)
url = '%s/@recently-touched/%s' % (
self.portal.absolute_url(), self.secretariat_user.getId())
browser.open(url, method='GET', headers={'Accept': 'application/json'})
self.assertEqual(200, browser.status_code)
self.assertEquals(
{'checked_out': [],
'recently_touched': []},
browser.json)
def test_returns_preview_pdf_url_as_string(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
adapter = getMultiAdapter((document, self.request), IBumblebeeOverlay)
self.assertIn('not_digitally_available.svg', adapter.get_preview_pdf_url())
def test_returns_false_if_no_version_id_is_given(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
adapter = getMultiAdapter((document, self.request), IBumblebeeOverlay)
self.assertFalse(adapter.is_versioned_context())
def test_returns_none_if_no_document_is_available_to_checkout(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
adapter = getMultiAdapter((document, self.request), IBumblebeeOverlay)
self.assertIsNone(None, adapter.get_checkout_url())
def test_returns_none_if_document_has_no_file(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
adapter = getMultiAdapter((document, self.request), IBumblebeeOverlay)
self.assertIsNone(adapter.get_file())
def test_returns_reference_number(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
adapter = getMultiAdapter((document, self.request), IBumblebeeOverlay)
self.assertEqual('Client1 / 1 / 1', adapter.get_reference_number())
def test_get_overlay_adapter_for_documents(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
adapter = getMultiAdapter((document, self.request), IBumblebeeOverlay)
self.assertIsInstance(adapter, BumblebeeBaseDocumentOverlay)
def test_linked_id_if_user_exists_with_no_fullname_anonymous_allowed(self):
set_allow_anonymous_view_about(self.portal, True)
create(Builder('user')).setMemberProperties(mapping={'fullname': ''})
self.assertEquals(
'<a href="http://nohost/plone/author/john.doe">john.doe</a>',
readable_author(object, 'john.doe'))
def test_linked_fullname_if_user_exists_and_anonymous_allowed(self):
set_allow_anonymous_view_about(self.portal, True)
create(Builder('user'))
self.assertEquals(
'<a href="http://nohost/plone/author/john.doe">Doe John</a>',
readable_author(object, 'john.doe'))
def create_proposals_word(self):
proposal1 = create(
Builder('proposal')
.within(self.dossier_baufrau)
.having(committee=self.committee_law_model,
title=u'Genehmigung der Anstellung von Hannah Baufrau als '
u'Sachbearbeiterin einem Besch\xe4ftigungsgrad von 90%')
.relate_to(self.document_baufrau_1,
self.document_baufrau_2,
self.document_baufrau_3)
.with_proposal_file(assets.load('vertragsentwurf.docx'))
.as_submitted())
self.meeting_word.schedule_proposal(proposal1.load_model())
self.meeting_word.schedule_ad_hoc(
u'Genehmigung der Bestellung von Hannah Baufrau als Sachbearbeterin '
u'einem Besch\xe4ftigungsgrad von 90%')
proposal2 = create(
Builder('proposal')
.within(self.dossier_laws_1)
.having(committee=self.committee_law_model,
title=u'Revision der Rechtslage f\xfcr eine Liberalisierung')
.relate_to(self.document_laws_1, self.document_laws_2)
.with_proposal_file(assets.load('vertragsentwurf.docx')))
self.meeting_word.schedule_ad_hoc(
u'Revision der Linkslage f\xfcr eine Liberalisierung')
def test_dont_show_mimetype_icon_per_default(self, browser):
create(Builder('content page')
.titled('A page')
.having(subject=['budget']))
view = SubjectListingView().visit()
self.assertEquals([], view.mimetype_images)
def test_send_empty_documents(self, browser):
dossier = create(Builder("dossier"))
document = create(Builder("document").within(dossier))
mail = self.send_documents(dossier, [document, ])
self.assert_mail_links_to(mail, document.absolute_url())
def test_umlauts_are_normalized_for_letter_index(self, browser):
create(Builder('content page')
.having(subject=['\xc3\xa4bc']))
view = SubjectListingView().visit()
self.assertEquals('A', view.current_letter)
self.assertEquals([u'\xe4bc'], view.subjects)
def test_object_renaming_is_not_journalized(self, browser):
"""When a object gets copied, it has to be renamed after the creation,
to use the correct format, but this shouldn't add additional journal
entries.
"""
repo_1 = create(Builder('repository'))
repo_2 = create(Builder('repository'))
dossier = create(Builder('dossier').within(repo_1))
create(Builder('document').within(dossier))
paths = {'paths:list': ['/'.join(dossier.getPhysicalPath())]}
browser.login().open(repo_2, view="copy_items", data=paths)
browser.css('#contentActionMenus a#paste').first.click()
copy = repo_2.listFolderContents()[-1]
browser.open(copy, view='tabbedview_view-journal')
listing = browser.css('.listing').first
titles = [row.get('Title') for row in listing.dicts()]
self.assertNotIn(u'Object moved: copy of Testdokum\xe4nt',
titles, '"Object moved" unexpectedly journalized')
self.assertNotIn(u'Object cut: copy of Testdokum\xe4nt', titles,
'"Object cut" unexpectedly journalized')
self.assertEqual(['Dossier modified: dossier-2',
'Dossier added: dossier-1',
u'Document added: copy of Testdokum\xe4nt',
'Dossier modified: dossier-1',
u'Document added: Testdokum\xe4nt',
'Dossier added: dossier-1'], titles)
def test_person_can_be_edited_in_browser(self, browser):
contactfolder = create(Builder('contactfolder'))
peter = create(Builder('person')
.having(firstname=u'Peter', lastname=u'M\xfcller'))
browser.login().open(contactfolder, view=peter.wrapper_id)
browser.find("Edit").click()
browser.fill({'Salutation': u'Sir',
'Academic title': u'Dr',
'Firstname': u'Hanspeter',
'Lastname': u'Hansj\xf6rg',
'Description': u'Pellentesque posuere.'}).submit()
self.assertEquals([u'Changes saved'], info_messages())
person = Person.get(peter.person_id)
self.assertIsNotNone(person)
self.assertEqual(u'Sir', person.salutation)
self.assertEqual(u'Dr', person.academic_title)
self.assertEqual(u'Hanspeter', person.firstname)
self.assertEqual(u'Hansj\xf6rg', person.lastname)
self.assertEqual(u'Pellentesque posuere.', person.description)
def test_creating_a_new_graphicblock(self, browser):
book = create(Builder('book').titled('The book'))
chapter = create(Builder('chapter').titled('The chapter').within(book))
browser.login().open(chapter)
factoriesmenu.add('Graphic Block')
with asset('diagram.pdf') as diagram:
browser.fill({'Title': 'The Graphicblock',
'PDF document': diagram}).save()
self.assertEquals(chapter, browser.context,
'Expected redirect to chapter view after savin')
image = browser.css('.BlockOverallWrapper.graphicblock'
' .simplelayout-block-wrapper img').first
self.assertDictContainsSubset(
{'height': '1228',
'width': '868'},
image.attrib)
browser.open(image.attrib['src'])
self.assertEquals('image/jpeg',
browser.headers.get('Content-Type'))
def test_slider_adds_slick_config_if_available(self, browser):
self.manage_set_language_settings(default='de',
supported=['de'],
use_combined=False,
content_negotiation=False)
container = create(Builder('slider container')
.within(self.folder)
.having(slick_config=json.dumps({'is_chuck': True}))
.titled(u'Slider Container'))
create(Builder('slider pane')
.within(container)
.titled(u'Pane 1')
.with_dummy_image())
browser.login().visit(self.folder)
self.assertEqual(
{u'labels': {u'pause': u'Pause',
u'play': u'Abspielen',
u'prev': u'Vorheriges Bild',
u'next': u'N\xe4chstes Bild'},
u'is_chuck': True},
json.loads(browser.css('#slider-panes').first.get('data-settings')))
def test_build_tree_with_group_memberships(self):
self._create_structure()
john = create(Builder('user'))
group = create(Builder('group')
.titled('Group')
.with_members(john))
self.a1.manage_setLocalRoles(group.getId(), ['Contributor'])
self.a1.reindexObject()
self.portal.REQUEST.set('principalid', john.getId())
view = queryMultiAdapter((self.portal, self.portal.REQUEST),
name='build_principal_role_tree')
view()
tree = view.build_tree()['children']
level1 = tree[0]
self.assertEquals('/'.join(self.folder.getPhysicalPath()),
level1['item'].getPath())
level2 = level1['children'][0]
self.assertEquals('/'.join(self.a.getPhysicalPath()),
level2['item'].getPath())
level3 = level2['children'][0]
self.assertEquals('/'.join(self.a1.getPhysicalPath()),
level3['item'].getPath())
def test_contains_proposal_and_freetext_agendaitems(self, browser):
self.maxDiff = None
meeting = create(
Builder('meeting').having(
committee=self.committee_model).link_with(
self.meeting_dossier))
proposal = create(
Builder('proposal').within(self.dossier).having(
title='Mach doch',
committee=self.committee.load_model(),
legal_basis=u'We may do it',
decision_draft=u'Proposal approved',
initial_position=u'We should do it.',
proposed_action=u'Do it.',
considerations=u'Uhm....').as_submitted())
create(
Builder('agenda_item').having(title=u'foo',
number=u'2',
meeting=meeting))
create(
Builder('agenda_item').having(meeting=meeting,
proposal=proposal.load_model(),
discussion=u'I say Nay!',
number=u'1'))
browser.login().open(meeting.get_url(view='agenda_item_list/as_json'))
self.assertEqual([{
u'decision_number': None,
u'description': u'Mach doch',
u'dossier_reference_number': u'Client1 1 / 1',
u'html:considerations': u'Uhm....',
u'html:copy_for_attention': None,
u'html:decision': u'Proposal approved',
u'html:decision_draft': u'Proposal approved',
u'html:disclose_to': None,
u'html:discussion': u'I say Nay!',
u'html:initial_position': u'We should do it.',
u'html:legal_basis': u'We may do it',
u'html:proposed_action': u'Do it.',
u'html:publish_in': None,
u'is_paragraph': False,
u'number': u'1.',
u'repository_folder_title': u'',
u'title': u'Mach doch'
}, {
u'decision_number': None,
u'description': u'foo',
u'dossier_reference_number': None,
u'html:considerations': None,
u'html:copy_for_attention': None,
u'html:decision': None,
u'html:decision_draft': None,
u'html:disclose_to': None,
u'html:discussion': None,
u'html:initial_position': None,
u'html:legal_basis': None,
u'html:proposed_action': None,
u'html:publish_in': None,
u'is_paragraph': False,
u'number': u'2.',
u'repository_folder_title': None,
u'title': u'foo'
}], browser.json.get('agenda_items'))
def test_is_not_all_supplied_with_subdossier_and_mails(self):
self.login(self.dossier_responsible)
create(Builder('dossier').within(self.empty_dossier))
create(Builder('mail').within(self.empty_dossier).with_dummy_message())
self.assertFalse(self.empty_dossier.is_all_supplied())
def test_is_not_all_supplied_with_subdossier_and_document(self):
self.login(self.dossier_responsible)
create(Builder('dossier').within(self.empty_dossier))
create(Builder('document').within(self.empty_dossier))
self.assertFalse(self.empty_dossier.is_all_supplied())
def test_is_all_supplied_without_any_subdossiers(self):
self.login(self.dossier_responsible)
create(Builder('document').within(self.empty_dossier))
self.assertTrue(self.empty_dossier.is_all_supplied())
def sub_document(self):
return create(
Builder("mail").with_message(MAIL_DATA).within(self.subdossier))
def test_is_prefixed_with_task_and_starts_at_1(self):
task1 = create(Builder('task'))
self.assertEquals('task-1', task1.id)
def test_is_incremented_by_1(self):
task1 = create(Builder('task'))
task2 = create(Builder('task'))
self.assertEquals('task-1', task1.id)
self.assertEquals('task-2', task2.id)
def create_mail_inbound(self):
dossier = create(Builder("dossier"))
mail = inbound.createMailInContainer(dossier, MAIL_DATA)
return mail
def test_document_without_file_is_not_digitally_available(self):
document_without_file = create(Builder("document"))
self.assertFalse(document_without_file.digitally_available)
def create_mail(self):
mail = create(Builder("mail").with_message(MAIL_DATA))
return mail
def test_filename_getter_return_none_if_no_file_is_available(self):
document = create(Builder('document'))
self.assertIsNone(document.get_filename())
def create_mail_quickupload(self):
dossier = create(Builder("dossier"))
mail = create(
Builder('quickuploaded_mail').within(dossier).with_message(
MAIL_DATA))
return mail
def test_is_not_a_mail(self):
document = create(Builder('document'))
self.assertFalse(document.is_mail)
def test_document_with_file_is_digitally_available(self):
document_with_file = create(Builder("document").with_dummy_content())
self.assertTrue(document_with_file.digitally_available)
def setUp(self):
super(TestPublicTrial, self).setUp()
self.document = create(Builder('document')
.having(public_trial='private'))
def test_filename_getter_returns_filename_if_file_is_available(self):
document = create(Builder('document')
.titled('Foo')
.attach_file_containing('foo', name=u'foo.txt'))
self.assertEqual(u'foo.txt', document.get_filename())
def test_adding_document_with_a_real_name_as_author_dont_change_author_name(self):
document = create(Builder('document')
.having(document_author='Muster Peter')
.with_dummy_content())
self.assertEquals('Muster Peter', document.document_author)
def setUp(self):
super(TestArchivalFileField, self).setUp()
self.dossier = create(Builder('dossier'))
self.grant('Manager')
def setUp(self):
super(TestDocumentMimetype, self).setUp()
self.dossier = create(Builder("dossier"))
transaction.commit()
def test_upload_file(self):
document = create(Builder("document"))
field = IDocumentSchema['file']
file = NamedBlobFile('bla bla', filename=u'test.txt')
field.set(document, file)
self.assertTrue(field.get(document).data == 'bla bla')
def setUp(self):
super(TestDocumentDefaultValues, self).setUp()
self.dossier = create(Builder('dossier'))
def test_documents_provide_IBaseDocument(self):
document = create(Builder("document"))
self.assertProvides(document, interface=IBaseDocument)
def test_get_parent_inbox_returns_none_for_document_in_dossier(self):
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier))
self.assertIsNone(document.get_parent_inbox())
def test_documents_provide_IDocumentSchema(self):
document = create(Builder("document"))
self.assertProvides(document, interface=IDocumentSchema)
def test_document_inside_a_task_is_not_movable(self):
task = create(Builder('task'))
doc = create(Builder('document').within(task))
self.assertFalse(doc.is_movable())
def test_is_office_connector_editable_mimetype_check_is_case_insensitive(self):
self.grant('Reader', 'Contributor', 'Editor')
dossier = create(Builder('dossier'))
document = create(Builder('document').within(dossier).with_dummy_content())
document.file.contentType = document.file.contentType.upper()
self.assertTrue(document.is_office_connector_editable())
def test_is_removed(self):
document_a = create(Builder('document'))
document_b = create(Builder('document').removed())
self.assertFalse(document_a.is_removed)
self.assertTrue(document_b.is_removed)
def test_get_parent_inbox_returns_inbox_for_document_in_inbox(self):
inbox = create(Builder('inbox'))
document = create(Builder('document').within(inbox))
self.assertEqual(inbox, document.get_parent_inbox())
def test_linked_id_if_user_exists_with_no_fullname(self):
create(Builder('user')).setMemberProperties(mapping={'fullname': ''})
self.assertEquals(
'<a href="http://nohost/plone/author/john.doe">john.doe</a>',
readable_author(object, 'john.doe'))
def test_document_inside_a_dossier_is_movable(self):
dossier = create(Builder('dossier'))
doc = create(Builder('document').within(dossier))
self.assertTrue(doc.is_movable())
