def test_assemble_return_value(self):
self.view.searchterms = ['One', 'Two']
self.view.earliest_date = AlexDate(1970)
self.view.latest_date = AlexDate(1980)
self.view.local_only = True
self.view.unverified_only = False
event_filter = self.presenter._build_filter_object()
self.assertEqual(EventFilter, event_filter.__class__)
self.assertEqual(['One', 'Two'], event_filter.searchterms)
self.assertEqual(AlexDate(1970), event_filter.earliest_date)
self.assertEqual(AlexDate(1980), event_filter.latest_date)
self.assertTrue(event_filter.local_only)
self.assertFalse(event_filter.unverified_only)
def get(self):
'''
Gets an AlexDate. Non integer input is silently ignored.
If the year is empty, None is returned. If the date
is not a valid AlexDate, an InvalidDateException is
thrown.
'''
year_as_int = None
month_as_int = None
day_as_int = None
try:
year_as_int = int(self.year)
except ValueError:
self.year = ''
try:
month_as_int = int(self.month)
except ValueError:
self.month = ''
try:
day_as_int = int(self.day)
except ValueError:
self.day = ''
if self.year == '':
return None
return AlexDate(year_as_int, month_as_int, day_as_int)
def check_document_event_reference_new(self):
print("Checking new document event reference...", end='')
reference = self.document_window.references[0]
dialog = reference.event_selection_dialog
self.document_window.presenter.goto_first()
original_references = len(reference.listbox.get_items())
self.event_window.presenter.goto_last()
self.start_dialog(reference._get_reference_event)
# Verify we got the correct event from the event window
self.assertEquals(dialog.date_entry.get(), AlexDate(1961, 5, 1))
# "go to" page 2
dialog.presenter.update_event_list()
# Select the event and close dialog
event = dialog.event_list_box.get_items()[0]
dialog.event_list_box.set(event)
dialog.presenter.ok_action()
self.assertEquals(original_references + 1,
len(reference.listbox.get_items()))
self.document_window.presenter.goto_last()
self.document_window.presenter.goto_first()
self.assertEquals(original_references + 1,
len(reference.listbox.get_items()))
print("OK")
def export_info_object_hook(obj):
'''
This function is used for deserializing ExportInfo json objects
'''
if 'cd_name' in obj:
export_info = ExportInfo()
export_info.start_date = obj['start_date']
export_info.end_date = obj['end_date']
export_info.signature = obj['signature']
export_info.cd_name = obj['cd_name']
export_info.pagecontent = obj['pagecontent']
export_info.start_image = obj['start_image']
return export_info
if '_year' in obj:
return AlexDate(obj['_year'], obj['_month'], obj['_day'])
if 'description' in obj:
return SystematicPoint(obj['id'], obj['description'])
if 'node_id' in obj:
return SystematicIdentifier(obj['node_id'], obj['roman'],
obj['subfolder'])
return obj
def test_invalid_date(self):
exception_raised = False
try:
AlexDate(None)
except InvalidDateException:
exception_raised = True
self.assertTrue(exception_raised)
def test_valid_date(self):
self.view.days = ["1"]
self.view.months = ["12"]
self.view.years = ["1960"]
self.presenter.ok_action()
self.assertEqual(AlexDate(1960, 12, 1), self.view.return_value)
def testDateValidationCombinedFail(self):
exception = None
try:
AlexDate(year=1971, month=2, day=29)
except InvalidDateException as e:
exception = e
self.assertEqual("Illegal date: 29.2.1971!", str(exception))
def testDateValidationYearAndMonthAndDay(self):
exception = None
try:
AlexDate(year=1970, month=12, day=31)
except InvalidDateException as e:
exception = e
self.assertFalse(exception)
def testDateValidationDayOutOfRange(self):
exception = None
try:
AlexDate(year=1970, month=12, day=32)
except InvalidDateException as e:
exception = e
self.assertEqual("Day 32 is out of range (1-31)!", str(exception))
def testDateValidationNonIntDay(self):
exception = None
try:
AlexDate(year=1970, month=12, day="bla")
except InvalidDateException as e:
exception = e
self.assertEqual("bla is not a valid day!", str(exception))
def testDateValidationMonthOutOfRange(self):
exception = None
try:
AlexDate(year=1970, month=13)
except InvalidDateException as e:
exception = e
self.assertEqual("Month 13 is out of range (1-12)!", str(exception))
def testDateValidationYear(self):
exception = None
try:
AlexDate(year=1970)
except InvalidDateException as e:
exception = e
self.assertFalse(exception)
def testDateValidationYearOutOfRange(self):
exception = None
try:
AlexDate(year=3001)
except InvalidDateException as e:
exception = e
self.assertEqual("Year 3001 is out of range (0-3000)!", str(exception))
def testDateValidationCombinedWorking(self):
exception = None
try:
AlexDate(year=1972, month=2, day=29)
except InvalidDateException as e:
exception = e
self.assertFalse(exception)
def testDateValidationNonIntYear(self):
exception = None
try:
AlexDate(year="bla")
except InvalidDateException as e:
exception = e
self.assertEqual("bla is not a valid year!", str(exception))
def check_create_event(self):
print("Checking creation of event works...", end='')
dialog = self.event_window.dialogs[EventWindow.DATE_RANGE_DIALOG]
self.start_dialog(self.event_window._create_new)
set_date_range(dialog, AlexDate(1941), AlexDate(1942))
self.close_dialog(dialog)
self.event_window._description_widget.set("Completely new event.")
self.event_window_presenter.goto_first()
self.event_window_presenter.goto_next()
event = self.event_window.entity
self.assertEquals(1941000001, event.id)
self.assertEquals("Completely new event.", event.description)
print("OK")
def test_fetch_doc_and_event_ids_II(self):
der_filter = DocumentEventReferenceFilter()
der_filter.earliest_date = AlexDate(1950)
references = self.dao.fetch_doc_event_references(der_filter)
self.assertEqual(1, len(references.keys()))
self.assertEqual(1, len(references[4]))
self.assertIn(1960013001, references[4])
self.assertIn(4, references)
def test_empty_day_and_month(self):
self.view.days = [""]
self.view.months = [""]
self.view.years = ["1970"]
self.presenter.ok_action()
self.assertEqual(AlexDate(1970), self.view.return_value)
def set_current_event(self, event_id):
if event_id is not None:
event = self.event_dao.get_by_id(event_id)
else:
event = Event()
event.daterange = AlexDateRange(AlexDate(1936), None)
message = Message(CONF_EVENT_CHANGED, event=event)
self.message_broker.send_message(message)
def check_goto_event(self):
print("Checking going to nearest selected event works...", end='')
dialog = self.event_window.dialogs[BaseWindow.GOTO_DIALOG]
self.start_dialog(self.event_window._activate_record_dialog)
set_date(dialog, AlexDate(1960, 1, 1))
self.close_dialog(dialog)
self.assert_that_event_is(1960013001)
print("OK")
def test_filtering_latest_date(self):
event_filter = EventFilter()
event_filter.latest_date = AlexDate(1960, 1, 30)
filter_expression_builder = EventFilterExpressionBuilder()
filter_expression = filter_expression_builder.create_filter_expression(
event_filter)
event = self.dao.get_first(filter_expression)
self.assertEqual(event.id, 1940000001)
event = self.dao.get_last(filter_expression)
self.assertEqual(event.id, 1960013001)
def ok_action(self):
try:
(day, month, year) = self._basic_input_conversion(0)
except Exception as e:
return
# Leave further input validation to the AlexDate class
try:
self._view.return_value = AlexDate(year, month, day)
except InvalidDateException as e:
self._view.errormessage = e.args[0]
def setUp(self):
self.export_info = ExportInfo()
self.export_info = ExportInfo()
self.export_info.cd_name = "TEST_CD"
self.export_info.start_date = AlexDate(1973, 5, 1)
self.export_info.end_date = AlexDate(1974, 5, 1)
self.export_info.location_id = SystematicPoint(
SystematicIdentifier("1.2.3", 4, 5), "dummy description")
self.export_info_json = '{%s, %s, %s, %s}' % (
'"cd_name": "TEST_CD"',
'"end_date": {"_day": 1, "_month": 5, "_year": 1974}',
'"location_id": {%s, %s}' %
('"description": "dummy description"',
'"id": {"node_id": "1.2.3", "roman": 4, "subfolder": 5}'),
'"start_date": {"_day": 1, "_month": 5, "_year": 1973}')
self.message_broker = MessageBroker()
self.generation_engine = MagicMock(spec=GenerationEngine)
self.presenter = ChronoCDExporterMenuAdditionsPresenter(
self.message_broker, self.generation_engine)
self.presenter.view = MagicMock()
def check_event_cross_reference_new(self):
print("Checking create new event cross reference...", end='')
reference = self.event_window.references[0]
dialog = reference.event_selection_dialog
self.event_window_presenter.goto_first()
self.assertEquals(len(reference.items), 2)
self.start_dialog(reference._select_new_cross_reference)
dialog.presenter.view.date_entry.set(AlexDate(1961, 5, 1))
dialog.presenter.update_event_list()
dialog.presenter.view.event_list_box.set(
dialog.presenter.view.event_list[0])
dialog.presenter.ok_action()
self.wait()
self.assertEquals(len(reference.items), 3)
print("OK")
def check_filtering_events(self):
print("Checking filtering events works...", end='')
dialog = self.event_window.dialogs[BaseWindow.FILTER_DIALOG]
self.start_dialog(self.event_window._toggle_filter)
dialog.earliest_date = AlexDate(1961, 1, 1)
self.close_dialog(dialog)
self.assert_that_event_is(1961050101)
self.event_window_presenter.goto_first()
self.assert_that_event_is(1961050101)
# Turn filtering off
self.event_window._toggle_filter()
self.assert_that_event_is(1961050101)
self.event_window_presenter.goto_first()
self.assert_that_event_is(1940000001)
print("OK")
def check_filtering_events_with_empty_selection(self):
print("Checking filtering events works even if nothing is selected...",
end='')
dialog = self.event_window.dialogs[BaseWindow.FILTER_DIALOG]
self.start_dialog(self.event_window._toggle_filter)
dialog.earliest_date = AlexDate(1980, 1, 1)
self.close_dialog(dialog)
self.assert_no_event()
self.event_window_presenter.goto_first()
self.assert_no_event()
# Turn filtering off
self.event_window._toggle_filter()
self.assert_no_event()
self.event_window_presenter.goto_first()
self.assert_that_event_is(1940000001)
print("OK")
class EventTypeReferencesPresenterTest(BaseIntegrationTest):
existing_event = Event(1940000001)
non_existing_event = Event()
non_existing_event.daterange = AlexDateRange(AlexDate(1930), None)
def setUp(self):
super().setUp()
self.injector = self.get_injector(PresentersModule())
self.event_service = self.injector.get(
baseinjectorkeys.EVENT_SERVICE_KEY)
self.event_type_dao = self.injector.get(
baseinjectorkeys.EVENT_TYPE_DAO_KEY)
self.presenter = self.injector.get(
guiinjectorkeys.EVENT_TYPE_REFERENCES_PRESENTER_KEY)
self.view = MagicMock(spec=DocumentFileReferencesView)
self.presenter.view = self.view
def receive_message(self, message):
BaseIntegrationTest.receive_message(self, message)
if message.key == REQ_SAVE_CURRENT_EVENT:
self.event_service.save(self.view.current_event)
@data([1940000001, 2], [1950000001, 1], [1961050101, 0])
@unpack
def test_receive_message_1(self, event_id, number_of_references):
'''
Assert that the event types are set on event changes.
'''
message = Message(CONF_EVENT_CHANGED,
event=self.event_service.get_by_id(event_id))
self.message_broker.send_message(message)
self.assertEqual(number_of_references, len(self.view.items))
def test_load_event_types(self):
'''
Just an additional test when there is now event set. Can't be done via
message.
'''
self.presenter._load_event_types(None)
self.assertEqual(0, len(self.view.items))
@data([existing_event, 3], [non_existing_event, 1])
@unpack
def test_add_event_type(self, event, number_of_references):
message = Message(CONF_EVENT_CHANGED, event=event)
self.message_broker.send_message(message)
self.view.new_event_type = self.event_type_dao.get_by_id(
EventTypeIdentifier(3, 2))
self.presenter.add_event_type_reference()
self.assertEqual(number_of_references,
len(self.event_service.get_event_types(event)))
def test_add_event_type_2(self):
'''
Trying to readd already added type
'''
event = self.event_service.get_by_id(1940000001)
event_type = self.event_type_dao.get_by_id(EventTypeIdentifier(5, 2))
message = Message(CONF_EVENT_CHANGED, event=event)
self.message_broker.send_message(message)
self.view.new_event_type = event_type
self.assertEqual(2, len(self.event_service.get_event_types(event)))
self.presenter.add_event_type_reference()
self.assertEqual(2, len(self.event_service.get_event_types(event)))
def test_add_event_type_3(self):
'''
Test when no event type is selected
'''
event = self.event_service.get_by_id(1940000001)
message = Message(CONF_EVENT_CHANGED, event=event)
self.message_broker.send_message(message)
self.view.new_event_type = None
self.assertEqual(2, len(self.event_service.get_event_types(event)))
self.presenter.add_event_type_reference()
self.assertEqual(2, len(self.event_service.get_event_types(event)))
def test_remove_event_type(self):
event = self.event_service.get_by_id(1940000001)
event_type = self.event_type_dao.get_by_id(EventTypeIdentifier(5, 2))
message = Message(CONF_EVENT_CHANGED, event=event)
self.message_broker.send_message(message)
self.view.selected_item = event_type
self.assertEqual(2, len(self.event_service.get_event_types(event)))
self.presenter.remove_event_type_reference()
self.assertEqual(1, len(self.event_service.get_event_types(event)))
def test_remove_event_type_2(self):
'''
Test with no type selected.
'''
event = self.event_service.get_by_id(1940000001)
message = Message(CONF_EVENT_CHANGED, event=event)
self.message_broker.send_message(message)
self.view.selected_item = None
self.assertEqual(2, len(self.event_service.get_event_types(event)))
self.presenter.remove_event_type_reference()
self.assertEqual(2, len(self.event_service.get_event_types(event)))
def testUpdateEventList1(self):
self.presenter.view.date = AlexDate(1950)
self.presenter.update_event_list()
self.assertEqual(len(self.presenter.view.event_list), 1)
self.assertEqual("%s" % self.presenter.view.event_list[0], "1950: Zweites Ereignis")
def test_get_events_for_date(self):
alex_date = AlexDate(1940)
event_list = self.dao.get_events_for_date(alex_date)
self.assertEqual(len(event_list), 1)
self.assertEqual(event_list[0].id, 1940000001)
def test_get_next_free_sequence_id(self):
alex_date = AlexDate(1940)
self.assertEqual(self.dao._get_next_free_sequence_id(alex_date), 2)
alex_date = AlexDate(1941)
self.assertEqual(self.dao._get_next_free_sequence_id(alex_date), 1)
