def test_author_indexers(self):
"""check the author indexers."""
doc1 = createContentInContainer(self.portal,
'opengever.document.document',
title=u"Doc One",
document_author=u'Hugo Boss',
document_date=datetime.date(
2011, 1, 1))
self.assertEquals(obj2brain(doc1).document_author, 'Hugo Boss')
self.assertEquals(
index_data_for(doc1).get('sortable_author'), u'Hugo Boss')
# without a author
doc1.document_author = None
doc1.reindexObject()
self.assertEquals(obj2brain(doc1).document_author, None)
self.assertEquals(index_data_for(doc1).get('sortable_author'), u'')
# with a non-ascii characters including author
doc1.document_author = u'H\xfcgo B\xf6ss'
doc1.reindexObject()
self.assertEquals(
obj2brain(doc1).document_author, 'H\xc3\xbcgo B\xc3\xb6ss')
self.assertEquals(
index_data_for(doc1).get('sortable_author'), u'H\xfcgo B\xf6ss')
def test_filing_no_is_not_indexed_for_default_dossiers(self):
self.login(self.regular_user)
self.dossier.reindexObject()
self.assertEquals(None, index_data_for(self.dossier).get('filing_no'))
self.assertEquals(None, index_data_for(self.dossier).get('searchable_filing_no'))
def test_author_indexers(self):
"""check the author indexers."""
doc1 = createContentInContainer(
self.portal, 'opengever.document.document',
title=u"Doc One", document_author=u'Hugo Boss',
document_date=datetime.date(2011, 1, 1))
self.assertEquals(obj2brain(doc1).document_author, 'Hugo Boss')
self.assertEquals(
index_data_for(doc1).get('sortable_author'),
u'Hugo Boss')
# without a author
doc1.document_author = None
doc1.reindexObject()
self.assertEquals(obj2brain(doc1).document_author, None)
self.assertEquals(
index_data_for(doc1).get('sortable_author'), u'')
# with a non-ascii characters including author
doc1.document_author = u'H\xfcgo B\xf6ss'
doc1.reindexObject()
self.assertEquals(
obj2brain(doc1).document_author, 'H\xc3\xbcgo B\xc3\xb6ss')
self.assertEquals(
index_data_for(doc1).get('sortable_author'), u'H\xfcgo B\xf6ss')
def test_file_extension_uses_extension_of_original_message_if_exists(self):
self.login(self.regular_user)
self.assertEqual('.msg',
index_data_for(self.mail_msg).get('file_extension'))
self.assertEqual('.eml',
index_data_for(self.mail_eml).get('file_extension'))
def test_file_extension_uses_extension_of_original_message_if_exists(self):
self.login(self.regular_user)
self.assertEqual('.msg',
index_data_for(self.mail_msg).get('file_extension'))
self.assertEqual('.eml',
index_data_for(self.mail_eml).get('file_extension'))
def test_document_type_indexer(self):
document = create(Builder("document"))
self.assertEqual(index_data_for(document)['document_type'], None)
IDocumentMetadata(document).document_type = "question"
document.reindexObject()
self.assertEqual(index_data_for(document)['document_type'], "question")
def test_reindexes_distinct_parent_and_related_documents(self):
self.login(self.dossier_responsible)
principal = 'user:{}'.format(self.secretariat_user.id)
self.assertNotIn(principal,
index_data_for(self.dossier)['allowedRolesAndUsers'])
self.assertNotIn(principal,
index_data_for(self.document)['allowedRolesAndUsers'])
task = create(Builder('task')
.within(self.dossier)
.titled(u'Aufgabe 1')
.having(responsible_client='fa',
responsible=self.secretariat_user.id,
issuer=self.dossier_responsible.getId(),
task_type='correction',
deadline=date(2016, 11, 1))
.in_state('task-state-in-progress')
.relate_to(self.document))
self.assertIn(principal,
index_data_for(self.dossier)['allowedRolesAndUsers'])
self.assertIn(principal,
index_data_for(self.document)['allowedRolesAndUsers'])
self.assertIn(principal,
index_data_for(task)['allowedRolesAndUsers'])
def test_document_type_indexer(self):
document = create(Builder("document"))
self.assertEqual(index_data_for(document)['document_type'], None)
IDocumentMetadata(document).document_type = "question"
document.reindexObject()
self.assertEqual(index_data_for(document)['document_type'], "question")
def test_reindexes_distinct_parent_and_related_documents(self):
self.login(self.dossier_responsible)
principal = 'user:{}'.format(self.secretariat_user.id)
self.assertNotIn(principal,
index_data_for(self.dossier)['allowedRolesAndUsers'])
self.assertNotIn(principal,
index_data_for(self.document)['allowedRolesAndUsers'])
task = create(
Builder('task').within(self.dossier).titled(u'Aufgabe 1').having(
responsible_client='fa',
responsible=self.secretariat_user.id,
issuer=self.dossier_responsible.getId(),
task_type='correction',
deadline=date(2016, 11,
1)).in_state('task-state-in-progress').relate_to(
self.document))
self.assertIn(principal,
index_data_for(self.dossier)['allowedRolesAndUsers'])
self.assertIn(principal,
index_data_for(self.document)['allowedRolesAndUsers'])
self.assertIn(principal, index_data_for(task)['allowedRolesAndUsers'])
def test_filing_no_is_not_indexed_for_default_dossiers(self):
self.login(self.regular_user)
self.dossier.reindexObject()
self.assertEquals(None, index_data_for(self.dossier).get('filing_no'))
self.assertEquals(None, index_data_for(self.dossier).get('searchable_filing_no'))
def test_returns_empty_string_for_dossiers_without_filing_information(self):
dossier = create(Builder("dossier"))
# no number, no prefix
self.assertEquals(None, index_data_for(dossier).get('filing_no'))
self.assertEquals('',
index_data_for(dossier).get('searchable_filing_no'))
def test_filing_no_is_not_indexed_for_default_dossiers(self):
dossier = create(Builder("dossier")
.having(filing_prefix='directorate',
filing_no='SKA ARCH-Administration-2012-3'))
self.assertEquals(None, index_data_for(dossier).get('filing_no'))
self.assertEquals(None,
index_data_for(dossier).get('searchable_filing_no'))
def test_filing_no_is_not_indexed_for_default_dossiers(self):
dossier = create(
Builder("dossier").having(
filing_prefix='directorate',
filing_no='SKA ARCH-Administration-2012-3'))
self.assertEquals(None, index_data_for(dossier).get('filing_no'))
self.assertEquals(None,
index_data_for(dossier).get('searchable_filing_no'))
def test_returns_first_part_of_the_filing_number_for_dossiers_with_only_filing_prefix_information(self):
dossier = create(Builder("dossier")
.having(filing_prefix='directorate'))
self.assertEquals('OG-Directorate-?',
index_data_for(dossier).get('filing_no'))
self.assertEquals(['og', 'directorate'],
index_data_for(dossier).get('searchable_filing_no'))
def test_returns_empty_string_for_dossiers_without_filing_information(
self):
dossier = create(Builder("dossier"))
# no number, no prefix
self.assertEquals(None, index_data_for(dossier).get('filing_no'))
self.assertEquals('',
index_data_for(dossier).get('searchable_filing_no'))
def test_is_subdossier_index(self):
self.assertFalse(index_data_for(self.dossier).get('is_subdossier'))
self.assertTrue(index_data_for(self.subdossier).get('is_subdossier'))
dossiertemplate = create(Builder('dossiertemplate'))
sub_dossiertemplate = create(
Builder('dossiertemplate').within(dossiertemplate))
self.assertFalse(index_data_for(dossiertemplate).get('is_subdossier'))
self.assertTrue(
index_data_for(sub_dossiertemplate).get('is_subdossier'))
def test_returns_filing_number_for_dossiers_with_only_filing_prefix_information(self):
dossier = create(Builder("dossier")
.having(filing_prefix='directorate',
filing_no='SKA ARCH-Administration-2012-3'))
# with number and prefix
self.assertEquals('SKA ARCH-Administration-2012-3',
index_data_for(dossier).get('filing_no'))
self.assertEquals(['ska', 'arch', 'administration', '2012', '3'],
index_data_for(dossier).get('searchable_filing_no'))
def test_returns_first_part_of_the_filing_number_for_dossiers_with_only_filing_prefix_information(
self):
dossier = create(
Builder("dossier").having(filing_prefix='directorate'))
self.assertEquals('OG-Directorate-?',
index_data_for(dossier).get('filing_no'))
self.assertEquals(['og', 'directorate'],
index_data_for(dossier).get('searchable_filing_no'))
def test_returns_filing_number_for_dossiers_with_only_filing_prefix_information(
self):
dossier = create(
Builder("dossier").having(
filing_prefix='directorate',
filing_no='SKA ARCH-Administration-2012-3'))
# with number and prefix
self.assertEquals('SKA ARCH-Administration-2012-3',
index_data_for(dossier).get('filing_no'))
self.assertEquals(['ska', 'arch', 'administration', '2012', '3'],
index_data_for(dossier).get('searchable_filing_no'))
def test_filesize_indexers(self):
document = create(
Builder("document").attach_file_containing(u"content",
name=u"file.txt"))
document.reindexObject()
self.assertEqual(7, index_data_for(document).get('filesize'))
self.assertEqual(7, obj2brain(document).filesize)
document.file = None
document.reindexObject()
self.assertEqual(0, index_data_for(document).get('filesize'))
self.assertEqual(0, obj2brain(document).filesize)
def test_filesize_indexers(self):
document = create(
Builder("document")
.attach_file_containing(u"content", name=u"file.txt")
)
document.reindexObject()
self.assertEqual(7, index_data_for(document).get('filesize'))
self.assertEqual(7, obj2brain(document).filesize)
document.file = None
document.reindexObject()
self.assertEqual(0, index_data_for(document).get('filesize'))
self.assertEqual(0, obj2brain(document).filesize)
def test_file_extension_indexers(self):
document = create(
Builder("document")
.titled(u'D\xf6k\xfcm\xe4nt')
.attach_file_containing(u"content", name=u"file.txt")
)
document.reindexObject()
self.assertEqual(u'.txt', index_data_for(document).get('file_extension'))
self.assertEqual(u'.txt', obj2brain(document).file_extension)
document.file = None
document.reindexObject()
self.assertEqual(u'', index_data_for(document).get('file_extension'))
self.assertEqual(u'', obj2brain(document).file_extension)
def test_file_extension_indexers(self):
document = create(
Builder("document").titled(
u'D\xf6k\xfcm\xe4nt').attach_file_containing(u"content",
name=u"file.txt"))
document.reindexObject()
self.assertEqual(u'.txt',
index_data_for(document).get('file_extension'))
self.assertEqual(u'.txt', obj2brain(document).file_extension)
document.file = None
document.reindexObject()
self.assertEqual(u'', index_data_for(document).get('file_extension'))
self.assertEqual(u'', obj2brain(document).file_extension)
def test_dossiertemplate_searchable_text_contains_keywords(self):
self.login(self.regular_user)
self.dossiertemplate.reindexObject()
self.assertIn(
'secret',
index_data_for(self.dossiertemplate).get('SearchableText'),
)
self.assertIn(
'special',
index_data_for(self.dossiertemplate).get('SearchableText'),
)
def test_dossier_searchable_text_contains_keywords(self):
self.login(self.regular_user)
self.dossier.reindexObject()
self.assertIn(
'finanzverwaltung',
index_data_for(self.dossier).get('SearchableText'),
)
self.assertIn(
'vertrage',
index_data_for(self.dossier).get('SearchableText'),
)
def test_dossiertemplate_searchable_text_contains_keywords(self):
self.login(self.regular_user)
self.dossiertemplate.reindexObject()
self.assertIn(
'secret',
index_data_for(self.dossiertemplate).get('SearchableText'),
)
self.assertIn(
'special',
index_data_for(self.dossiertemplate).get('SearchableText'),
)
def test_dossier_searchable_text_contains_keywords(self):
self.login(self.regular_user)
self.dossier.reindexObject()
self.assertIn(
'finanzverwaltung',
index_data_for(self.dossier).get('SearchableText'),
)
self.assertIn(
'vertrage',
index_data_for(self.dossier).get('SearchableText'),
)
def test_index_is_updated_when_end_date_is_changed_during_resolving(self, browser):
self.grant('Reader', 'Contributor', 'Editor', 'Reviewer')
create(Builder('document')
.within(self.dossier)
.having(document_date=date(2015, 1, 1)))
former_indexed_value = index_data_for(self.dossier).get('retention_expiration')
browser.login().open(self.dossier)
browser.find('dossier-transition-resolve').click()
self.assertNotEqual(
former_indexed_value,
index_data_for(self.dossier).get('retention_expiration'))
def assert_document_1_created(self, parent):
document_1 = parent.objectValues()[0]
self.assertTrue(document_1.digitally_available)
self.assertIsNotNone(document_1.file)
self.assertEqual(22198, len(document_1.file.data))
self.assertEqual(
u'david.erni',
document_1.document_author)
self.assertEqual(
date(2007, 1, 1),
document_1.document_date)
self.assertEqual(
tuple(),
document_1.keywords)
self.assertTrue(
document_1.preserved_as_paper)
self.assertEqual(
[],
document_1.relatedItems)
self.assertEqual(
'document-state-draft',
api.content.get_state(document_1))
self.assertEqual(
u'Bewerbung Hanspeter M\xfcller',
document_1.title)
self.assertEqual(
IAnnotations(document_1)[BUNDLE_GUID_KEY],
index_data_for(document_1)[GUID_INDEX_NAME])
def test_mail_searchable_text_contains_keywords(self):
mail = create(
Builder("mail").having(keywords=(u'Pick me!', u'Keyw\xf6rd')))
self.assertItemsEqual(
[u'1', u'1', 'client1', 'no', 'subject', 'keyword', 'me', 'pick'],
index_data_for(mail).get('SearchableText'))
def test_proposal_can_be_created_in_browser_and_strips_whitespace(
self, browser):
self.login(self.dossier_responsible, browser)
browser.open(self.dossier)
factoriesmenu.add('Proposal')
browser.fill({
'Title': u'A pr\xf6posal',
'Committee': u'Rechnungspr\xfcfungskommission',
'Proposal template': u'Geb\xfchren',
'Attachments': [self.document],
}).save()
statusmessages.assert_no_error_messages()
statusmessages.assert_message('Item created')
proposal = browser.context
self.assertEqual(1, len(proposal.relatedItems))
self.assertEqual(self.document, proposal.relatedItems[0].to_object)
self.assertEqual(u'A pr\xf6posal', proposal.title)
model = proposal.load_model()
self.assertIsNotNone(model)
self.assertEqual(u'A pr\xf6posal', model.title)
self.assertIsNone(model.submitted_title)
self.assertEqual(Oguid.for_object(proposal), model.oguid)
self.assertEqual('robert.ziegler', model.creator)
self.assertEqual(u'Vertr\xe4ge und Vereinbarungen',
model.repository_folder_title)
self.assertEqual(u'en', model.language)
self.assertTrue(
set(['a', 'proposal'
]).issubset(set(index_data_for(proposal)['SearchableText'])))
self.assertEqual(u'Client1 1.1 / 1', model.dossier_reference_number)
def test_searchable_text(self):
self.login(self.workspace_admin)
self.assertItemsEqual([
'fix', 'user', 'login', 'authentication', 'is', 'no', 'longer',
'possible'
],
index_data_for(self.todo).get('SearchableText'))
def assert_processes_folder_created(self, parent):
folder_process = parent.get('organigramm-prozesse')
self.assertEqual('0.0. Organigramm, Prozesse', folder_process.Title())
self.assertEqual(u'Organigramm, Prozesse', folder_process.title_de)
self.assertIsNone(folder_process.title_fr)
self.assertEqual('organigramm-prozesse', folder_process.getId())
self.assertEqual(30, ILifeCycle(folder_process).custody_period)
self.assertEqual(u'', folder_process.description)
self.assertEqual(u'', folder_process.former_reference)
self.assertEqual(u'privacy_layer_no',
IClassification(folder_process).privacy_layer)
self.assertEqual(u'unchecked',
IClassification(folder_process).public_trial)
self.assertEqual(
u'',
IClassification(folder_process).public_trial_statement)
self.assertEqual(
"0",
IReferenceNumberPrefix(folder_process).reference_number_prefix)
self.assertEqual(u'', folder_process.referenced_activity)
self.assertEqual(5, ILifeCycle(folder_process).retention_period)
self.assertEqual(date(2005, 1, 1), folder_process.valid_from)
self.assertEqual(date(2020, 1, 1), folder_process.valid_until)
self.assertEqual('repositoryfolder-state-active',
api.content.get_state(folder_process))
self.assertIsNone(getattr(folder_process, 'guid', None))
self.assertIsNone(getattr(folder_process, 'parent_guid', None))
self.assertEqual(
IAnnotations(folder_process)[BUNDLE_GUID_KEY],
index_data_for(folder_process)[GUID_INDEX_NAME])
return folder_process
def assert_mail2_created(self, parent):
mail = self.find_by_title(parent, u'Lorem Ipsum')
self.assertIsNotNone(mail.message)
self.assertEqual(920, len(mail.message.data))
self.assertEqual(
IAnnotations(mail)[BUNDLE_GUID_KEY],
index_data_for(mail)[GUID_INDEX_NAME])
def test_searchable_text_contains_keywords(self):
sablon_template = create(
Builder("sablontemplate")
.having(keywords=(u'Pick me!', u'Keyw\xf6rd')))
self.assertItemsEqual(
[u'1', u'1', 'client1', 'testdokumant', 'keyword', 'me', 'pick'],
index_data_for(sablon_template).get('SearchableText'))
def test_external_reference(self):
doc = create(
Builder('document').having(author=u'Hugo Boss',
title=u'Docment',
foreign_reference=u'qpr-900-9001-\xf8'))
self.assertEquals(u'qpr-900-9001-\xf8',
index_data_for(doc).get('external_reference'))
def test_creator_index_gets_updated(self):
migrator = CreatorMigrator(
self.portal, {'old.user': '******'}, 'move')
migrator.migrate()
# Index should be up to date
self.assertEquals('new.user',
index_data_for(self.dossier).get('Creator'))
self.assertEquals('new.user',
index_data_for(self.doc).get('Creator'))
# Metadata should be up to date
self.assertEquals(('new.user', ), obj2brain(self.dossier).listCreators)
self.assertEquals(('new.user', ), obj2brain(self.doc).listCreators)
self.assertEquals('new.user', obj2brain(self.dossier).Creator)
self.assertEquals('new.user', obj2brain(self.doc).Creator)
def test_index_is_updated_when_end_date_is_changed_during_resolving(
self, browser):
self.grant('Reader', 'Contributor', 'Editor', 'Reviewer')
create(
Builder('document').within(
self.dossier).having(document_date=date(2015, 1, 1)))
former_indexed_value = index_data_for(
self.dossier).get('retention_expiration')
browser.login().open(self.dossier)
browser.find('dossier-transition-resolve').click()
self.assertNotEqual(
former_indexed_value,
index_data_for(self.dossier).get('retention_expiration'))
def test_public_trial_index_exists_and_is_used(self):
catalog = getToolByName(self.portal, "portal_catalog")
# check if index exists
self.assertIn("public_trial", catalog.indexes())
# check if object got indexed
self.assertEquals("private", index_data_for(self.document).get("public_trial"))
def test_external_reference(self):
dossier = create(
Builder("dossier").titled(u"Dossier").having(
external_reference=u'qpr-900-9001-\xf7').within(
self.repo_folder))
self.assertEquals(u'qpr-900-9001-\xf7',
index_data_for(dossier).get('external_reference'))
def test_dossier_searchable_text_contains_external_reference(self):
dossier = create(
Builder("dossier").titled(u"Dossier").having(
external_reference=u'22900-2017').within(self.repo_folder))
self.assertItemsEqual(
[u'1', u'3', 'client1', 'dossier', '22900', '2017'],
index_data_for(dossier).get('SearchableText'))
def assert_mail_2_created(self, parent):
mail = parent.objectValues()[3]
self.assertIsNotNone(mail.message)
self.assertEqual(920, len(mail.message.data))
self.assertEqual(u'Lorem Ipsum', mail.title)
self.assertEqual(
IAnnotations(mail)[BUNDLE_GUID_KEY],
index_data_for(mail)[GUID_INDEX_NAME])
def test_external_reference(self):
doc = create(Builder('document').having(
author=u'Hugo Boss',
title=u'Docment',
foreign_reference=u'qpr-900-9001-\xf8'))
self.assertEquals(
u'qpr-900-9001-\xf8',
index_data_for(doc).get('external_reference'))
def test_dossier_searchable_text_contains_keywords(self):
dossier_with_keywords = create(
Builder("dossier").titled(u"Dossier").having(
keywords=(u'Pick me!',
u'Keyw\xf6rd')).within(self.repo_folder))
self.assertItemsEqual(
[u'1', u'3', 'client1', 'dossier', 'keyword', 'me', 'pick'],
index_data_for(dossier_with_keywords).get('SearchableText'))
def test_sortable_title_indexer_accomodates_padding_for_five_numbers(self):
numeric_part = "1 2 3 4 5"
alphabetic_part = u"".join(
["a" for i in range(CONTENT_TITLE_LENGTH - len(numeric_part))])
title = numeric_part + alphabetic_part
document = create(Builder("document").titled(title))
self.assertEquals('0001 0002 0003 0004 0005' + alphabetic_part,
index_data_for(document).get('sortable_title'))
def assert_mail_2_created(self, parent):
mail = parent.objectValues()[3]
self.assertIsNotNone(mail.message)
self.assertEqual(920, len(mail.message.data))
self.assertEqual(u'Lorem Ipsum', mail.title)
self.assertEqual(
IAnnotations(mail)[BUNDLE_GUID_KEY],
index_data_for(mail)[GUID_INDEX_NAME])
def test_public_trial_index_exists_and_is_used(self):
catalog = getToolByName(self.portal, 'portal_catalog')
# check if index exists
self.assertIn('public_trial', catalog.indexes())
# check if object got indexed
self.assertEquals('private',
index_data_for(self.document).get('public_trial'))
def assert_mail3_created(self):
mail = self.find_by_title(
self.dossier, u'Mail in bestehendem Examplecontent Dossier')
self.assertIsNotNone(mail.message)
self.assertEqual(920, len(mail.message.data))
self.assertEqual(
IAnnotations(mail)[BUNDLE_GUID_KEY],
index_data_for(mail)[GUID_INDEX_NAME])
def test_dossier_searchable_text_contains_external_reference(self):
self.login(self.regular_user)
self.dossier.reindexObject()
self.assertIn(
'qpr',
index_data_for(self.dossier).get('SearchableText'),
)
self.assertIn(
u'900',
index_data_for(self.dossier).get('SearchableText'),
)
self.assertIn(
u'9001',
index_data_for(self.dossier).get('SearchableText'),
)
def assert_mail_3_created(self):
mail = self.dossier.objectValues()[-1]
self.assertIsNotNone(mail.message)
self.assertEqual(920, len(mail.message.data))
self.assertEqual(
u'Mail in bestehendem Examplecontent Dossier', mail.title)
self.assertEqual(
IAnnotations(mail)[BUNDLE_GUID_KEY],
index_data_for(mail)[GUID_INDEX_NAME])
def test_mail_searchable_text_contains_keywords(self):
self.login(self.regular_user)
self.mail_eml.keywords = (u'Pick me!', u'Keyw\xf6rd')
self.mail_eml.reindexObject()
index_data = index_data_for(self.mail_eml).get('SearchableText')
self.assertIn('pick', index_data)
self.assertIn('me', index_data)
self.assertIn('keyword', index_data)
def test_sortable_title_indexer_accomodates_padding_for_five_numbers(self):
numeric_part = "1 2 3 4 5"
alphabetic_part = u"".join(["a" for i in range(CONTENT_TITLE_LENGTH
- len(numeric_part))])
title = numeric_part + alphabetic_part
document = create(Builder("document").titled(title))
self.assertEquals(
'0001 0002 0003 0004 0005' + alphabetic_part,
index_data_for(document).get('sortable_title'))
def test_returns_empty_string_for_dossiers_without_filing_information(self):
self.login(self.regular_user)
self.dossier.reindexObject()
self.assertEquals(
None,
index_data_for(self.dossier).get('filing_no'),
)
self.assert_index_value(u'', 'searchable_filing_no', self.dossier)
def test_full_text_indexing_with_plain_text(self):
sample_file = NamedBlobFile('foobar barfoo', filename=u'test.txt')
doc1 = createContentInContainer(
self.portal, 'opengever.document.document',
title=u"Doc One",
document_author=u'Hugo Boss',
file=sample_file)
searchable_text = index_data_for(doc1).get('SearchableText')
self.assertIn('foobar', searchable_text)
self.assertIn('barfoo', searchable_text)
def test_filing_no_is_also_in_searchable_text(self):
self.login(self.regular_user)
IDossier(self.dossier).filing_prefix = self.filing_prefix
IFilingNumber(self.dossier).filing_no = self.filing_no
self.dossier.reindexObject()
searchable_text_data = index_data_for(self.dossier).get('SearchableText')
for segment in self.searchable_filing_no:
self.assertIn(segment, searchable_text_data)
def test_searchable_text(self):
doc1 = createContentInContainer(
self.portal, 'opengever.document.document',
title=u"Doc One",
document_author=u'Hugo Boss',
keywords=('foo', 'bar'),
document_date=datetime.date(2011,1,1),
receipt_date=datetime.date(2011, 2, 1))
self.assertEquals(
index_data_for(doc1).get('SearchableText'),
['doc', 'one', 'foo', 'bar', 'hugo', 'boss', 'client1', '1', '1'])
def test_also_reindexes_containing_subdossier(self):
"""The dossier are reindex manually
"""
self.login(self.dossier_responsible)
principal = 'user:{}'.format(self.secretariat_user.id)
self.assertNotIn(principal,
index_data_for(self.dossier)['allowedRolesAndUsers'])
self.assertNotIn(principal,
index_data_for(self.subdossier)['allowedRolesAndUsers'])
self.assertNotIn(principal,
index_data_for(self.subsubdossier)['allowedRolesAndUsers'])
create(Builder('task')
.within(self.dossier)
.titled(u'Aufgabe 1')
.having(responsible_client='fa',
responsible=self.secretariat_user.id,
issuer=self.dossier_responsible.getId(),
task_type='correction',
deadline=date(2016, 11, 1))
.in_state('task-state-in-progress')
.relate_to(self.document))
self.assertIn(principal,
index_data_for(self.dossier)['allowedRolesAndUsers'])
self.assertIn(principal,
index_data_for(self.subdossier)['allowedRolesAndUsers'])
self.assertIn(principal,
index_data_for(self.subsubdossier)['allowedRolesAndUsers'])
def test_sortable_title_indexer_accomodates_padding_for_five_numbers(self):
self.login(self.regular_user)
numeric_part = "1 2 3 4 5"
alphabetic_part = u"".join(["a" for i in range(CONTENT_TITLE_LENGTH
- len(numeric_part))])
title = numeric_part + alphabetic_part
self.dossier.setTitle(title)
self.dossier.reindexObject(["sortable_title"])
self.assertEquals(
'0001 0002 0003 0004 0005' + alphabetic_part,
index_data_for(self.dossier).get('sortable_title'))
def test_searchable_text(self):
self.task.title = u'Test Aufgabe'
self.task.text = u'Lorem ipsum olor sit amet'
create_ogds_user(TEST_USER_ID, firstname='Hugo', lastname='Boss')
self.task.responsible = TEST_USER_ID
self.task.reindexObject()
self.assertEquals(
index_data_for(self.task).get('SearchableText'),
['test', 'aufgabe', 'lorem', 'ipsum', 'olor', 'sit',
'amet', '1', 'boss', 'hugo', 'test_user_1_'])
