def set_current_document(self, document_id):
if document_id is not None:
document = self.document_dao.get_by_id(document_id)
else:
document = Document()
document.document_type = DocumentType(1)
message = Message(CONF_DOCUMENT_CHANGED, document=document)
self.message_broker.send_message(message)
def testNoOverwriting(self):
description ='Stadtzeitung vom 23.4.1975. Irgend ein Text'
flyer_doc_type = DocumentType(2)
flyer_doc_type.description = "Flyer"
entity = Document(4711)
entity.document_type = flyer_doc_type
entity.description = description
entity = self.post_processor.run(entity)
self.assertTrue(entity.document_type != None)
self.assertEqual('Flyer', entity.document_type.description)
def testRemoveSystematicEntryFromDocumentLocation(self):
document = Document(56)
document.standort = "1.2.III-4"
systematic_identifier = SystematicIdentifier("1.2", 3, 4)
systematic_point = QualifiedSystematicPoint(
SystematicPoint(systematic_identifier, "Description"), True)
self.service.remove_systematic_entry_from_document(
document, systematic_point)
self.assertEqual(document.standort, None)
self.references_dao.set_signature_for_document_id.assert_called_with(
56, None)
def test_find_all_entities(self):
self.document_dao.get_count.return_value = 5
self.document_dao.find.return_value = [
Document(1),
Document(2),
Document(3),
Document(4),
Document(5)
]
result = self.service.find(None, 1, 10)
self.assertEqual(5, len(result.entities))
self.assertEqual(1, result.number_of_pages)
def testJournalArticle(self):
descriptions = ('Stadtzeitung vom 23.4.1975. Irgend ein Text',
'Stadtzeitung vom 23. April 1975. Irgend ein Text',
'B.Z., 3. April 2014: Noch ein Text')
for description in descriptions:
with self.subTest(description=description):
entity = Document(4711)
entity.description = description
entity = self.post_processor.run(entity)
self.assertTrue(entity.document_type != None)
self.assertEqual('Zeitungsartikel', entity.document_type.description)
def testRemoveSystematicEntryFromDocumentRelations(self):
document = Document(56)
document.standort = "1.2.III-4"
systematic_identifier = SystematicIdentifier("1.2", 3, 4)
systematic_point = SystematicPoint(systematic_identifier,
"Description")
qualified_systematic_node = QualifiedSystematicPoint(
systematic_point, False)
self.service.remove_systematic_entry_from_document(
document, qualified_systematic_node)
self.references_dao.remove_systematik_document_relation(
56, systematic_identifier)
def testAddSystematicEntryToDocumentWithLocation(self):
# Setup
document = Document(56)
document.standort = "1.2.III-4"
systematic_identifier = SystematicIdentifier("5.6", 7, 8)
systematic_node = SystematicPoint(systematic_identifier, "Description")
# Execution
self.service.add_systematic_entry_to_document(document,
systematic_node)
# Assertion
self.assertEqual(document.standort, "1.2.III-4")
self.references_dao.add_systematik_document_relation.assert_called_with(
systematic_identifier, 56)
def testFetchSystematicEntriesForDocument(self):
# Setup
document = Document(25)
signature = systematic_string_to_identifier("1.2.IV-3")
identifier1 = SystematicIdentifier("2.3", 5, 6)
identifier2 = SystematicIdentifier("3.4", 7, 8)
self.references_dao.fetch_systematik_ids_for_document_id = MagicMock(
return_value=[identifier1, identifier2])
self.references_dao.fetch_signature_for_document_id = MagicMock(
return_value=signature)
values = {
signature: SystematicPoint(signature, "signature"),
identifier1: SystematicPoint(identifier1, "identifier1"),
identifier2: SystematicPoint(identifier2, "identifier2")
}
def side_effect(arg):
return values[arg]
self.systematic_dao.get_by_id = MagicMock(side_effect=side_effect)
# Execution
result = self.service.fetch_systematic_entries_for_document(document)
# Assertion
self.assertEqual(len(result), 3)
self.assertIn(QualifiedSystematicPoint(values[signature], True),
result)
self.assertIn(QualifiedSystematicPoint(values[identifier1], False),
result)
self.assertIn(QualifiedSystematicPoint(values[identifier2], False),
result)
def testFlyer(self):
descriptions = ('Flyer: Irgendein Flyer',
' Flyer: Irgendein Flyer',
' Flyer :Irgendein Flyer',
'Flyer:Irgendein Flyer',
'Flyer :\tIrgendein Flyer')
for description in descriptions:
with self.subTest(description):
entity = Document(4711)
entity.description = description
entity = self.post_processor.run(entity)
self.assertTrue(entity.document_type != None)
self.assertEqual('Flyer', entity.document_type.description)
self.assertEqual('Irgendein Flyer', entity.description)
def testRealLifeTexts(self):
doc = Document(5)
file_info1 = DocumentFileInfo(5)
file_info1.filetype = 'txt'
file1 = os.path.join(self.text_base_dir, "00000005.txt")
file_info2 = DocumentFileInfo(10)
file_info2.filetype = 'txt'
file2 = os.path.join(self.text_base_dir, "00000011.txt")
file_info3 = DocumentFileInfo(11)
file_info3.filetype = 'txt'
file3 = os.path.join(self.text_base_dir, "00000012.txt")
values = {file_info1: file1, file_info2: file2, file_info3: file3}
def side_effect(arg):
return values[arg]
self.document_file_info_dao.get_file_infos_for_document.return_value = [
file_info1, file_info2, file_info3
]
self.document_file_manager.get_file_path.side_effect = side_effect
pdf = self.document_pdf_generation_service.generate_document_pdf(doc)
self.tmp_file.write(pdf)
self.document_file_info_dao.get_file_infos_for_document.assert_called_with(
5)
self.document_file_manager.get_file_path.assert_has_calls(
(call(file_info1), call(file_info2), call(file_info3)))
def test_find_paginated_entities(self):
self.document_dao.get_count.return_value = 5
self.document_dao.find.side_effect = ([
Document(1), Document(4), Document(8)
], [Document(11), Document(12)])
result = self.service.find(None, 1, 3)
self.assertEqual(3, len(result.entities))
self.assertEqual(1, result.entities[0].id)
self.assertEqual(4, result.entities[1].id)
self.assertEqual(8, result.entities[2].id)
self.assertEqual(2, result.number_of_pages)
result = self.service.find(None, 2, 3)
self.assertEqual(2, len(result.entities))
self.assertEqual(11, result.entities[0].id)
self.assertEqual(12, result.entities[1].id)
self.assertEqual(2, result.number_of_pages)
def add_button(self, master):
message = Message(REQ_SET_DOCUMENT, document=Document(1))
load_references_button = Button(
master,
text='Change document',
command=lambda m=message: self.message_broker.send_message(m))
load_references_button.pack(side=TOP)
def testDeleteIII(self):
# Entity is not yet persisted
self.view.entity = Document()
self.document_window_presenter.delete()
self.assertEqual(self.view.entity,
self.document_service.get_last(None))
def test_find_paginated_entities_with_filter(self):
self.document_dao.get_count.return_value = 4
self.document_dao.find.side_effect = ([Document(4),
Document(8)],
[Document(11),
Document(12)])
where = "egal"
result = self.service.find(where, 1, 2)
self.assertEqual(2, len(result.entities))
self.assertEqual(4, result.entities[0].id)
self.assertEqual(8, result.entities[1].id)
self.assertEqual(2, result.number_of_pages)
result = self.service.find(where, 2, 2)
self.assertEqual(2, len(result.entities))
self.assertEqual(11, result.entities[0].id)
self.assertEqual(12, result.entities[1].id)
self.assertEqual(2, result.number_of_pages)
def test_hashable_without_id(self):
dictionary = {}
document = Document()
exception_raised = False
try:
dictionary[document] = "bla"
except TypeError:
exception_raised = True
self.assertFalse(exception_raised)
def test_get_file_infos_for_document(self):
document = Document(1)
self.document_file_info_dao.get_file_infos_for_document.return_value = [
DocumentFileInfo(1)
]
file_infos = self.service.get_file_infos_for_document(document)
self.assertEqual(1, len(file_infos))
self.document_file_info_dao.get_file_infos_for_document.assert_called_once_with(
1)
def __init__(self):
config = Config(os.path.join(get_testfiles_dir(), "testconfig.xml"))
self.file_format_service = FileFormatService(config)
self.file_infos = {}
document = Document(1)
self.file_infos[document] = []
file_info = DocumentFileInfo(1)
file_info.document_id = 1
file_info.filetype = "tif"
file_info.resolution = 300
self.file_infos[document].append(file_info)
def test_add_document_file_working(self):
test_file = os.path.join(get_testfiles_dir(), "testfile.jpg")
document = Document(1)
file_info = DocumentFileInfo(1)
self.document_file_info_dao.create_new_file_info.return_value = file_info
self.service.add_document_file(document, test_file)
self.document_file_manager.add_file.assert_called_once_with(
test_file, file_info)
def test_utter_failure(self):
self.view.new_file = Document()
self.view.current_document = self.document_dao.get_last()
self.presenter.add_file()
self.assertMessage(ERROR_MESSAGE)
self.assertEqual(_("Unknown error while adding file"),
self.received_messages[0].message)
self.assertTrue(os.path.isfile(self.env.illegal_input_file))
self.assert_file_info_does_not_exist(15)
def testMissingHandler(self):
doc = Document(1)
file_info = DocumentFileInfo(2)
file_info.filetype = 'xls'
self.document_file_info_dao.get_file_infos_for_document.return_value = [
file_info
]
pdf = self.document_pdf_generation_service.generate_document_pdf(doc)
self.tmp_file.write(pdf)
self.document_file_info_dao.get_file_infos_for_document.assert_called_with(
1)
def testAddSystematicEntryToDocumentWithoutLocation(self):
# Setup
document = Document(56)
systematic_node = SystematicPoint(SystematicIdentifier("1.2", 3, 4),
"Description")
self.references_dao.fetch_signature_for_document_id = MagicMock(
return_value=None)
# Execution
self.service.add_systematic_entry_to_document(document,
systematic_node)
# Assertion
self.references_dao.set_signature_for_document_id.assert_called_once_with(
document.id, systematic_node)
def test_hashing(self):
doc1 = Document()
doc2 = Document()
doc1.description = None
doc2.description = None
test_map = {}
test_map[doc1] = "eins"
test_map[doc2] = "zwei"
self.assertEqual(test_map[doc2], "zwei")
def testDelete(self):
document = Document(1)
file_infos = []
file_infos.append(DocumentFileInfo(2))
file_infos.append(DocumentFileInfo(3))
self.document_file_info_dao.get_file_infos_for_document = MagicMock(
return_value=file_infos)
self.document_dao.delete = MagicMock()
self.service.delete(document)
self.document_file_manager.delete_file.call_args_list = [
call(file_infos[0]), call(file_infos[1])
]
self.document_dao.delete.assert_called_once_with(1)
def test_pdf_generation(self):
document = Document(1)
self.document_file_info_dao.get_by_id.return_value = self.env.document_file_infos[
1]
self.document_file_info_dao.get_file_infos_for_document.return_value = [
self.env.document_file_infos[1], self.env.document_file_infos[3],
self.env.document_file_infos[2]
]
cache_path = self.document_file_manager.get_generated_file_path(
self.env.document_file_infos[1], DOCUMENT_PDF)
self.assertFalse(os.path.exists(cache_path))
pdf = self.file_provider.get_pdf(document)
self.assertFalse(pdf is None)
self.assertEquals(b'%PDF-1.3', pdf[0:8])
self.assertTrue(os.path.exists(cache_path))
def testSaveNewDocument(self):
document = Document()
document.description = "My description"
document.keywords = "My keywords"
document.condition = "My document state"
document.erfasser = self.injector.get(CreatorDao).get_by_id(2)
document.document_type = self.injector.get(DocumentTypeDao).get_by_id(
5)
self.dao.save(document)
document = self.dao.get_last()
self.assertEqual(15, document.id)
self.assertEqual("My description", document.description)
self.assertEqual("My keywords", document.keywords)
self.assertEqual("My document state", document.condition)
self.assertEqual(3, document.erfasser.id)
self.assertEqual("Flugblatt", document.document_type.description)
self.assertTrue(document.change_date)
self.assertTrue(document.creation_date)
def test_add_document_file_not_working(self):
test_file = os.path.join(get_testfiles_dir(), "testfile.jpg")
document = Document(1)
file_info = DocumentFileInfo(1)
self.document_file_info_dao.create_new_file_info.return_value = file_info
self.document_file_manager.add_file.side_effect = FileNotFoundError()
self.document_file_manager.delete_file.side_effect = Exception()
exception_raised = False
try:
self.service.add_document_file(document, test_file)
except FileNotFoundError:
exception_raised = True
self.assertTrue(exception_raised)
self.document_file_manager.add_file.assert_called_once_with(
test_file, file_info)
self.document_file_manager.delete_file.assert_called_once_with(
file_info)
self.document_file_info_dao.delete.assert_called_once_with(
file_info.id)
def testDocumentGeneration(self):
doc = Document(1)
self.document_file_info_dao.get_file_infos_for_document.return_value = [
self.env.document_file_infos[1], # tif
self.env.document_file_infos[3], # gif
self.env.document_file_infos[8], # pdf
self.env.document_file_infos[4]
] # jpg
values = {
self.env.document_file_infos[1]: self.env.file_paths[1],
self.env.document_file_infos[3]: self.env.file_paths[3],
self.env.document_file_infos[8]: self.env.file_paths[8],
self.env.document_file_infos[4]: self.env.file_paths[4]
}
def side_effect(arg):
return values[arg]
self.document_file_manager.get_file_path.side_effect = side_effect
pdf = self.document_pdf_generation_service.generate_document_pdf(doc)
self.tmp_file.write(pdf)
self.document_file_info_dao.get_file_infos_for_document.assert_called_with(
1)
self.document_file_manager.get_file_path.assert_has_calls(
(call(self.env.document_file_infos[1]),
call(self.env.document_file_infos[3]),
call(self.env.document_file_infos[8]),
call(self.env.document_file_infos[4])))
file = open(self.tmp_file.name, "rb")
reader = PdfFileReader(file)
self.assertEqual(3, reader.getNumPages())
def test_string_generation(self):
document = Document(4711)
document.description = "My document"
self.assertEqual("%s" % document, "4711: My document")
def test_string_generation_new_document(self):
document = Document()
self.assertEqual("%s" % document, _('New document'))
def send_message(self, number):
message = Message(REQ_SET_DOCUMENT, document=Document(number))
self.message_broker.send_message(message)