mirror of
https://github.com/lucaspalomodevelop/eventcally.git
synced 2026-03-13 00:07:22 +00:00
388 lines
14 KiB
Python
388 lines
14 KiB
Python
import pytest
|
|
|
|
from project.models import EventDateDefinition
|
|
|
|
|
|
def test_location_update_coordinate(client, app, db):
|
|
from project.models import Location
|
|
|
|
location = Location()
|
|
location.latitude = 51.9077888
|
|
location.longitude = 10.4333312
|
|
location.update_coordinate()
|
|
|
|
assert location.coordinate is not None
|
|
|
|
|
|
def test_event_category(client, app, db, seeder):
|
|
user_id, admin_unit_id = seeder.setup_base()
|
|
event_id = seeder.create_event(admin_unit_id)
|
|
|
|
with app.app_context():
|
|
from project.models import Event
|
|
|
|
event = Event.query.get(event_id)
|
|
event.categories = []
|
|
db.session.commit()
|
|
|
|
assert event.category is None
|
|
|
|
|
|
def test_event_properties(client, app, db, seeder):
|
|
with app.app_context():
|
|
from sqlalchemy.exc import IntegrityError
|
|
|
|
from project.dateutils import create_berlin_date
|
|
from project.models import Event, EventDateDefinition
|
|
|
|
event = Event()
|
|
assert event.min_start_definition is None
|
|
assert event.min_start is None
|
|
assert event.is_recurring is False
|
|
|
|
with pytest.raises(IntegrityError) as e:
|
|
event.validate()
|
|
assert e.value.orig.message == "At least one date defintion is required."
|
|
|
|
start = create_berlin_date(2030, 12, 31, 14, 30)
|
|
date_definition = EventDateDefinition()
|
|
date_definition.start = start
|
|
event.date_definitions = [date_definition]
|
|
assert event.min_start == start
|
|
|
|
|
|
def test_event_allday(client, app, db, seeder):
|
|
from project.dateutils import create_berlin_date
|
|
|
|
user_id, admin_unit_id = seeder.setup_base()
|
|
event_with_start_id = seeder.create_event(
|
|
admin_unit_id, allday=True, start=create_berlin_date(2030, 12, 31, 14, 30)
|
|
)
|
|
event_with_start_and_end_id = seeder.create_event(
|
|
admin_unit_id,
|
|
allday=True,
|
|
start=create_berlin_date(2030, 12, 31, 14, 30),
|
|
end=create_berlin_date(2031, 1, 1, 0, 0),
|
|
)
|
|
|
|
with app.app_context():
|
|
from project.models import Event
|
|
|
|
# With Start
|
|
event = Event.query.get(event_with_start_id)
|
|
date_definition = event.date_definitions[0]
|
|
assert date_definition.allday
|
|
assert date_definition.start == create_berlin_date(2030, 12, 31, 0, 0)
|
|
assert date_definition.end == create_berlin_date(2030, 12, 31, 23, 59, 59)
|
|
|
|
event_date = event.dates[0]
|
|
assert event_date.allday
|
|
assert event_date.start == create_berlin_date(2030, 12, 31, 0, 0)
|
|
assert event_date.end == create_berlin_date(2030, 12, 31, 23, 59, 59)
|
|
|
|
# With Start and End
|
|
event = Event.query.get(event_with_start_and_end_id)
|
|
date_definition = event.date_definitions[0]
|
|
assert date_definition.allday
|
|
assert date_definition.start == create_berlin_date(2030, 12, 31, 0, 0)
|
|
assert date_definition.end == create_berlin_date(2031, 1, 1, 23, 59, 59)
|
|
|
|
event_date = event.dates[0]
|
|
assert event_date.allday
|
|
assert event_date.start == create_berlin_date(2030, 12, 31, 0, 0)
|
|
assert event_date.end == create_berlin_date(2031, 1, 1, 23, 59, 59)
|
|
|
|
|
|
def test_event_has_multiple_dates(client, app, db, seeder):
|
|
_, admin_unit_id = seeder.setup_base()
|
|
event_with_recc_id = seeder.create_event(
|
|
admin_unit_id, recurrence_rule="RRULE:FREQ=DAILY;COUNT=7"
|
|
)
|
|
event_without_recc_id = seeder.create_event(admin_unit_id)
|
|
|
|
with app.app_context():
|
|
from project.models import Event
|
|
|
|
event_with_recc = Event.query.get(event_with_recc_id)
|
|
assert event_with_recc.has_multiple_dates() is True
|
|
|
|
event_without_recc = Event.query.get(event_without_recc_id)
|
|
assert event_without_recc.has_multiple_dates() is False
|
|
|
|
|
|
def test_oauth2_token(client, app):
|
|
from project.models import OAuth2Token
|
|
|
|
token = OAuth2Token()
|
|
token.revoked = True
|
|
assert not token.is_refresh_token_active()
|
|
|
|
token.revoked = False
|
|
token.issued_at = 0
|
|
token.expires_in = 0
|
|
assert not token.is_refresh_token_active()
|
|
|
|
|
|
def test_admin_unit_relations(client, app, db, seeder):
|
|
user_id, admin_unit_id = seeder.setup_base(log_in=False)
|
|
(
|
|
other_user_id,
|
|
other_admin_unit_id,
|
|
relation_id,
|
|
) = seeder.create_any_admin_unit_relation(admin_unit_id)
|
|
|
|
with app.app_context():
|
|
from project.services.admin_unit import get_admin_unit_by_id
|
|
|
|
admin_unit = get_admin_unit_by_id(admin_unit_id)
|
|
assert len(admin_unit.outgoing_relations) == 1
|
|
relation = admin_unit.outgoing_relations[0]
|
|
assert relation.id == relation_id
|
|
|
|
db.session.delete(relation)
|
|
db.session.commit()
|
|
assert len(admin_unit.outgoing_relations) == 0
|
|
|
|
|
|
def test_event_date_defintion_deletion(client, app, db, seeder):
|
|
_, admin_unit_id = seeder.setup_base(log_in=False)
|
|
event_id = seeder.create_event(admin_unit_id)
|
|
|
|
with app.app_context():
|
|
from project.models import Event
|
|
|
|
# Initial eine Definition
|
|
event = Event.query.get(event_id)
|
|
assert len(event.date_definitions) == 1
|
|
date_definition1 = event.date_definitions[0]
|
|
|
|
# Zweite Definition hinzufügen
|
|
date_definition2 = seeder.create_event_date_definition()
|
|
db.session.add(date_definition2)
|
|
event.date_definitions = [date_definition1, date_definition2]
|
|
db.session.commit()
|
|
|
|
event = Event.query.get(event_id)
|
|
assert len(event.date_definitions) == 2
|
|
assert len(EventDateDefinition.query.all()) == 2
|
|
|
|
# Erste Definition löschen
|
|
date_definition1, date_definition2 = event.date_definitions
|
|
date_definition2_id = date_definition2.id
|
|
|
|
db.session.delete(date_definition1)
|
|
db.session.commit()
|
|
|
|
event = Event.query.get(event_id)
|
|
assert len(event.date_definitions) == 1
|
|
assert len(EventDateDefinition.query.all()) == 1
|
|
assert event.date_definitions[0].id == date_definition2_id
|
|
|
|
|
|
def test_admin_unit_deletion(client, app, db, seeder):
|
|
user_id, admin_unit_id = seeder.setup_base(log_in=False)
|
|
my_event_id = seeder.create_event(admin_unit_id)
|
|
suggestion_id = seeder.create_event_suggestion(admin_unit_id)
|
|
event_place_id = seeder.upsert_default_event_place(admin_unit_id)
|
|
organizer_id = seeder.upsert_default_event_organizer(admin_unit_id)
|
|
invitation_id = seeder.create_invitation(admin_unit_id, "newbie@domain.com")
|
|
event_list_id = seeder.create_event_list(admin_unit_id, my_event_id)
|
|
|
|
other_user_id = seeder.create_user("other@test.de")
|
|
other_admin_unit_id = seeder.create_admin_unit(other_user_id, "Other Crew")
|
|
other_event_id = seeder.create_event(other_admin_unit_id)
|
|
incoming_reference_request_id = seeder.create_reference_request(
|
|
other_event_id, admin_unit_id
|
|
)
|
|
outgoing_reference_request_id = seeder.create_reference_request(
|
|
my_event_id, other_admin_unit_id
|
|
)
|
|
incoming_relation_id = seeder.create_admin_unit_relation(
|
|
other_admin_unit_id, admin_unit_id
|
|
)
|
|
outgoing_relation_id = seeder.create_admin_unit_relation(
|
|
admin_unit_id, other_admin_unit_id
|
|
)
|
|
incoming_reference_id = seeder.create_reference(other_event_id, admin_unit_id)
|
|
outgoing_reference_id = seeder.create_reference(my_event_id, other_admin_unit_id)
|
|
|
|
with app.app_context():
|
|
from project.models import (
|
|
AdminUnit,
|
|
AdminUnitMemberInvitation,
|
|
AdminUnitRelation,
|
|
Event,
|
|
EventDate,
|
|
EventDateDefinition,
|
|
EventList,
|
|
EventOrganizer,
|
|
EventPlace,
|
|
EventReference,
|
|
EventReferenceRequest,
|
|
EventSuggestion,
|
|
)
|
|
from project.services.admin_unit import get_admin_unit_by_id
|
|
|
|
admin_unit = get_admin_unit_by_id(admin_unit_id)
|
|
other_admin_unit = get_admin_unit_by_id(other_admin_unit_id)
|
|
my_event = Event.query.get(my_event_id)
|
|
date_id = my_event.dates[0].id
|
|
date_definition_id = my_event.date_definitions[0].id
|
|
|
|
db.session.delete(admin_unit)
|
|
db.session.commit()
|
|
assert len(other_admin_unit.outgoing_relations) == 0
|
|
|
|
assert Event.query.get(my_event_id) is None
|
|
assert EventDate.query.get(date_id) is None
|
|
assert EventDateDefinition.query.get(date_definition_id) is None
|
|
assert AdminUnitRelation.query.get(incoming_relation_id) is None
|
|
assert AdminUnitRelation.query.get(outgoing_relation_id) is None
|
|
assert EventReference.query.get(incoming_reference_id) is None
|
|
assert EventReference.query.get(outgoing_reference_id) is None
|
|
assert EventReferenceRequest.query.get(incoming_reference_request_id) is None
|
|
assert EventReferenceRequest.query.get(outgoing_reference_request_id) is None
|
|
assert EventSuggestion.query.get(suggestion_id) is None
|
|
assert EventPlace.query.get(event_place_id) is None
|
|
assert EventOrganizer.query.get(organizer_id) is None
|
|
assert AdminUnitMemberInvitation.query.get(invitation_id) is None
|
|
assert EventList.query.get(event_list_id) is None
|
|
|
|
assert AdminUnit.query.get(other_admin_unit_id) is not None
|
|
assert Event.query.get(other_event_id) is not None
|
|
|
|
|
|
def test_event_co_organizers_deletion(client, app, db, seeder):
|
|
user_id, admin_unit_id = seeder.setup_base(log_in=False)
|
|
event_id, organizer_a_id, organizer_b_id = seeder.create_event_with_co_organizers(
|
|
admin_unit_id
|
|
)
|
|
|
|
with app.app_context():
|
|
from project.models import Event, EventOrganizer
|
|
|
|
event = Event.query.get(event_id)
|
|
assert len(event.co_organizers) == 2
|
|
assert event.co_organizers[0].id == organizer_a_id
|
|
assert event.co_organizers[1].id == organizer_b_id
|
|
|
|
organizer_a = EventOrganizer.query.get(organizer_a_id)
|
|
db.session.delete(organizer_a)
|
|
db.session.commit()
|
|
assert len(event.co_organizers) == 1
|
|
assert event.co_organizers[0].id == organizer_b_id
|
|
|
|
db.session.delete(event)
|
|
db.session.commit()
|
|
assert EventOrganizer.query.get(organizer_b_id).id is not None
|
|
|
|
|
|
def test_admin_unit_verification(client, app, db, seeder):
|
|
user_id, admin_unit_id = seeder.setup_base(log_in=False, admin_unit_verified=False)
|
|
other_user_id = seeder.create_user("other@test.de")
|
|
other_admin_unit_id = seeder.create_admin_unit(other_user_id, "Other Crew")
|
|
|
|
with app.app_context():
|
|
from project.models import AdminUnit, AdminUnitRelation
|
|
|
|
new_admin_unit = AdminUnit()
|
|
assert not new_admin_unit.is_verified
|
|
|
|
admin_unit = AdminUnit.query.get(admin_unit_id)
|
|
admin_unit.can_verify_other = True
|
|
db.session.commit()
|
|
|
|
relation_id = seeder.create_admin_unit_relation(
|
|
admin_unit_id, other_admin_unit_id
|
|
)
|
|
|
|
all_verified = AdminUnit.query.filter(AdminUnit.is_verified).all()
|
|
assert len(all_verified) == 0
|
|
|
|
relation = AdminUnitRelation.query.get(relation_id)
|
|
relation.verify = True
|
|
db.session.commit()
|
|
|
|
other_admin_unit = AdminUnit.query.get(other_admin_unit_id)
|
|
assert other_admin_unit.is_verified
|
|
|
|
all_verified = AdminUnit.query.filter(AdminUnit.is_verified).all()
|
|
assert len(all_verified) == 1
|
|
assert all_verified[0].id == other_admin_unit_id
|
|
|
|
admin_unit = AdminUnit.query.get(admin_unit_id)
|
|
admin_unit.can_verify_other = False
|
|
db.session.commit()
|
|
|
|
all_verified = AdminUnit.query.filter(AdminUnit.is_verified).all()
|
|
assert len(all_verified) == 0
|
|
|
|
|
|
def test_admin_unit_invitations(client, app, db, seeder):
|
|
_, admin_unit_id = seeder.setup_base(log_in=False)
|
|
invitation_id = seeder.create_admin_unit_invitation(admin_unit_id)
|
|
|
|
with app.app_context():
|
|
from project.models import AdminUnitInvitation
|
|
from project.services.admin_unit import get_admin_unit_by_id
|
|
|
|
admin_unit = get_admin_unit_by_id(admin_unit_id)
|
|
assert len(admin_unit.admin_unit_invitations) == 1
|
|
|
|
admin_unit.can_invite_other = False
|
|
db.session.commit()
|
|
|
|
assert len(admin_unit.admin_unit_invitations) == 0
|
|
invitation = AdminUnitInvitation.query.get(invitation_id)
|
|
assert invitation is None
|
|
|
|
|
|
def test_event_list_deletion(client, app, db, seeder):
|
|
_, admin_unit_id = seeder.setup_base(log_in=False)
|
|
event_id = seeder.create_event(admin_unit_id)
|
|
event_list_a_id = seeder.create_event_list(admin_unit_id, event_id, "List A")
|
|
event_list_b_id = seeder.create_event_list(admin_unit_id, event_id, "List B")
|
|
|
|
with app.app_context():
|
|
from project.models import Event, EventList
|
|
|
|
event_list_a = EventList.query.get(event_list_a_id)
|
|
assert len(event_list_a.events) == 1
|
|
assert event_list_a.events[0].id == event_id
|
|
|
|
event_list_b = EventList.query.get(event_list_b_id)
|
|
assert len(event_list_b.events) == 1
|
|
assert event_list_b.events[0].id == event_id
|
|
|
|
event = Event.query.get(event_id)
|
|
assert len(event.event_lists) == 2
|
|
assert event.event_lists[0].id == event_list_a_id
|
|
assert event.event_lists[1].id == event_list_b_id
|
|
|
|
event_list_a = EventList.query.get(event_list_a_id)
|
|
db.session.delete(event_list_a)
|
|
db.session.commit()
|
|
assert len(event.event_lists) == 1
|
|
assert event.event_lists[0].id == event_list_b_id
|
|
|
|
event_list_b = EventList.query.get(event_list_b_id)
|
|
assert len(event_list_b.events) == 1
|
|
assert event_list_b.events[0].id == event_id
|
|
|
|
db.session.delete(event)
|
|
db.session.commit()
|
|
|
|
event_list_b = EventList.query.get(event_list_b_id)
|
|
assert len(event_list_b.events) == 0
|
|
|
|
|
|
def test_event_is_favored_by_current_user(client, app, db, seeder):
|
|
_, admin_unit_id = seeder.setup_base(log_in=False)
|
|
event_id = seeder.create_event(admin_unit_id)
|
|
|
|
with app.app_context():
|
|
from project.models import Event
|
|
|
|
event = Event.query.get(event_id)
|
|
assert event.is_favored_by_current_user() is False
|