mirror of
https://github.com/bringout/oca-ocb-security.git
synced 2026-04-21 22:52:02 +02:00
469 lines
18 KiB
Python
469 lines
18 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from datetime import datetime
|
|
from dateutil.relativedelta import relativedelta
|
|
from pytz import UTC
|
|
|
|
from odoo.exceptions import UserError
|
|
from odoo.addons.microsoft_calendar.utils.microsoft_event import MicrosoftEvent
|
|
from odoo.addons.microsoft_calendar.tests.common import TestCommon, patch_api
|
|
|
|
class TestMicrosoftEvent(TestCommon):
|
|
|
|
@patch_api
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.create_events_for_tests()
|
|
|
|
def test_already_mapped_events(self):
|
|
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
event_uid = self.simple_event.ms_universal_event_id
|
|
events = MicrosoftEvent([{
|
|
"type": "singleInstance",
|
|
"_odoo_id": self.simple_event.id,
|
|
"iCalUId": event_uid,
|
|
"id": event_id,
|
|
}])
|
|
|
|
# act
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(mapped._events), 1)
|
|
self.assertEqual(mapped._events[event_id]["_odoo_id"], self.simple_event.id)
|
|
|
|
def test_forbid_edit_outlook_recurring_event(self):
|
|
"""
|
|
Test that no user can edit a recurring event imported from Outlook
|
|
(identified by microsoft_recurrence_master_id), but that the sync
|
|
mechanism itself can still write through via dont_notify context.
|
|
"""
|
|
# Give the organizer user a Microsoft token
|
|
self.organizer_user.microsoft_calendar_token = "fake_token"
|
|
|
|
outlook_recurring_event, recurring_event = self.env['calendar.event'].with_context(dont_notify=True).create([
|
|
{
|
|
'name': 'Outlook Recurring Event',
|
|
'start': datetime(2023, 9, 25, 10, 0),
|
|
'stop': datetime(2023, 9, 25, 11, 0),
|
|
'microsoft_id': 'AAA123:BBB456',
|
|
'microsoft_recurrence_master_id': 'MASTER123',
|
|
'user_id': self.organizer_user.id,
|
|
},
|
|
{
|
|
'name': 'Regular Recurring Event',
|
|
'start': datetime(2023, 9, 25, 10, 0),
|
|
'stop': datetime(2023, 9, 25, 11, 0),
|
|
'user_id': self.organizer_user.id,
|
|
'partner_ids': [(4, self.organizer_user.partner_id.id)],
|
|
'recurrency': True,
|
|
'follow_recurrence': True,
|
|
'rrule_type': 'daily',
|
|
'interval': 1,
|
|
'end_type': 'count',
|
|
'count': 3,
|
|
},
|
|
])
|
|
|
|
# No user should be able to edit the Outlook event through Odoo
|
|
for user in [self.attendee_user, self.organizer_user]:
|
|
with self.assertRaises(UserError):
|
|
outlook_recurring_event.with_user(user).with_context(dont_notify=False).write({
|
|
'name': 'Trying to change name',
|
|
'recurrence_update': 'future_events',
|
|
})
|
|
self.assertEqual(outlook_recurring_event.name, 'Outlook Recurring Event')
|
|
|
|
# But changes from Microsoft sync itself should still work
|
|
outlook_recurring_event.with_context(dont_notify=True).write({
|
|
'name': 'Updated from Outlook',
|
|
'recurrence_update': 'future_events'
|
|
})
|
|
self.assertEqual(outlook_recurring_event.name, 'Updated from Outlook')
|
|
|
|
# Remove token: organizer is no longer synced to Outlook
|
|
self.organizer_user.microsoft_calendar_token = False
|
|
|
|
# Any user should be able to edit a non-Outlook recurring event
|
|
for user in [self.attendee_user, self.organizer_user]:
|
|
recurring_event.with_user(user).with_context(dont_notify=False).write({
|
|
'name': f'Changed by {user.name}',
|
|
'recurrence_update': 'future_events',
|
|
})
|
|
self.assertEqual(recurring_event.name, f'Changed by {user.name}')
|
|
|
|
def test_map_an_event_using_global_id(self):
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
event_uid = self.simple_event.ms_universal_event_id
|
|
events = MicrosoftEvent([{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": event_uid,
|
|
"id": event_id,
|
|
}])
|
|
|
|
# act
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(mapped._events), 1)
|
|
self.assertEqual(mapped._events[event_id]["_odoo_id"], self.simple_event.id)
|
|
|
|
def test_map_an_event_using_instance_id(self):
|
|
"""
|
|
Here, the Odoo event has an uid but the Outlook event has not.
|
|
"""
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
events = MicrosoftEvent([{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": False,
|
|
"id": event_id,
|
|
}])
|
|
|
|
# act
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(mapped._events), 1)
|
|
self.assertEqual(mapped._events[event_id]["_odoo_id"], self.simple_event.id)
|
|
|
|
def test_map_an_event_without_uid_using_instance_id(self):
|
|
"""
|
|
Here, the Odoo event has no uid but the Outlook event has one.
|
|
"""
|
|
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
event_uid = self.simple_event.ms_universal_event_id
|
|
self.simple_event.ms_universal_event_id = False
|
|
events = MicrosoftEvent([{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": event_uid,
|
|
"id": event_id,
|
|
}])
|
|
|
|
# act
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(mapped._events), 1)
|
|
self.assertEqual(mapped._events[event_id]["_odoo_id"], self.simple_event.id)
|
|
self.assertEqual(self.simple_event.ms_universal_event_id, event_uid)
|
|
|
|
def test_map_an_event_without_uid_using_instance_id_2(self):
|
|
"""
|
|
Here, both Odoo event and Outlook event have no uid.
|
|
"""
|
|
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
self.simple_event.ms_universal_event_id = False
|
|
events = MicrosoftEvent([{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": False,
|
|
"id": event_id,
|
|
}])
|
|
|
|
# act
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(mapped._events), 1)
|
|
self.assertEqual(mapped._events[event_id]["_odoo_id"], self.simple_event.id)
|
|
self.assertEqual(self.simple_event.ms_universal_event_id, False)
|
|
|
|
def test_map_a_recurrence_using_global_id(self):
|
|
|
|
# arrange
|
|
rec_id = self.recurrence.microsoft_id
|
|
rec_uid = self.recurrence.ms_universal_event_id
|
|
events = MicrosoftEvent([{
|
|
"type": "seriesMaster",
|
|
"_odoo_id": False,
|
|
"iCalUId": rec_uid,
|
|
"id": rec_id,
|
|
}])
|
|
|
|
# act
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(mapped._events), 1)
|
|
self.assertEqual(mapped._events[rec_id]["_odoo_id"], self.recurrence.id)
|
|
|
|
def test_map_a_recurrence_using_instance_id(self):
|
|
|
|
# arrange
|
|
rec_id = self.recurrence.microsoft_id
|
|
events = MicrosoftEvent([{
|
|
"type": "seriesMaster",
|
|
"_odoo_id": False,
|
|
"iCalUId": False,
|
|
"id": rec_id,
|
|
}])
|
|
|
|
# act
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(mapped._events), 1)
|
|
self.assertEqual(mapped._events[rec_id]["_odoo_id"], self.recurrence.id)
|
|
|
|
def test_try_to_map_mixed_of_single_events_and_recurrences(self):
|
|
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
event_uid = self.simple_event.ms_universal_event_id
|
|
rec_id = self.recurrence.microsoft_id
|
|
rec_uid = self.recurrence.ms_universal_event_id
|
|
|
|
events = MicrosoftEvent([
|
|
{
|
|
"type": "seriesMaster",
|
|
"_odoo_id": False,
|
|
"iCalUId": rec_uid,
|
|
"id": rec_id,
|
|
},
|
|
{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": event_uid,
|
|
"id": event_id,
|
|
},
|
|
])
|
|
|
|
# act & assert
|
|
with self.assertRaises(TypeError):
|
|
events._load_odoo_ids_from_db(self.env)
|
|
|
|
def test_match_event_only(self):
|
|
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
event_uid = self.simple_event.ms_universal_event_id
|
|
events = MicrosoftEvent([{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": event_uid,
|
|
"id": event_id,
|
|
}])
|
|
|
|
# act
|
|
matched = events.match_with_odoo_events(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(matched._events), 1)
|
|
self.assertEqual(matched._events[event_id]["_odoo_id"], self.simple_event.id)
|
|
|
|
def test_match_recurrence_only(self):
|
|
|
|
# arrange
|
|
rec_id = self.recurrence.microsoft_id
|
|
rec_uid = self.recurrence.ms_universal_event_id
|
|
events = MicrosoftEvent([{
|
|
"type": "seriesMaster",
|
|
"_odoo_id": False,
|
|
"iCalUId": rec_uid,
|
|
"id": rec_id,
|
|
}])
|
|
|
|
# act
|
|
matched = events.match_with_odoo_events(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(matched._events), 1)
|
|
self.assertEqual(matched._events[rec_id]["_odoo_id"], self.recurrence.id)
|
|
|
|
def test_match_not_typed_recurrence(self):
|
|
"""
|
|
When a recurrence is deleted, Outlook returns the id of the deleted recurrence
|
|
without the type of event, so it's not directly possible to know that it's a
|
|
recurrence.
|
|
"""
|
|
# arrange
|
|
rec_id = self.recurrence.microsoft_id
|
|
rec_uid = self.recurrence.ms_universal_event_id
|
|
events = MicrosoftEvent([{
|
|
"@removed": {
|
|
"reason": "deleted",
|
|
},
|
|
"_odoo_id": False,
|
|
"iCalUId": rec_uid,
|
|
"id": rec_id,
|
|
}])
|
|
|
|
# act
|
|
matched = events.match_with_odoo_events(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(matched._events), 1)
|
|
self.assertEqual(matched._events[rec_id]["_odoo_id"], self.recurrence.id)
|
|
|
|
def test_match_mix_of_events_and_recurrences(self):
|
|
|
|
# arrange
|
|
event_id = self.simple_event.microsoft_id
|
|
event_uid = self.simple_event.ms_universal_event_id
|
|
rec_id = self.recurrence.microsoft_id
|
|
rec_uid = self.recurrence.ms_universal_event_id
|
|
|
|
events = MicrosoftEvent([
|
|
{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": event_uid,
|
|
"id": event_id,
|
|
},
|
|
{
|
|
"@removed": {
|
|
"reason": "deleted",
|
|
},
|
|
"_odoo_id": False,
|
|
"iCalUId": rec_uid,
|
|
"id": rec_id,
|
|
}
|
|
])
|
|
|
|
# act
|
|
matched = events.match_with_odoo_events(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(matched._events), 2)
|
|
self.assertEqual(matched._events[event_id]["_odoo_id"], self.simple_event.id)
|
|
self.assertEqual(matched._events[rec_id]["_odoo_id"], self.recurrence.id)
|
|
|
|
def test_ignore_not_found_items(self):
|
|
|
|
# arrange
|
|
events = MicrosoftEvent([{
|
|
"type": "singleInstance",
|
|
"_odoo_id": False,
|
|
"iCalUId": "UNKNOWN_EVENT",
|
|
"id": "UNKNOWN_EVENT",
|
|
}])
|
|
|
|
# act
|
|
matched = events.match_with_odoo_events(self.env)
|
|
|
|
# assert
|
|
self.assertEqual(len(matched._events), 0)
|
|
|
|
def test_search_set_ms_universal_event_id(self):
|
|
not_synced_events = self.env['calendar.event'].search([('ms_universal_event_id', '=', False)])
|
|
synced_events = self.env['calendar.event'].search([('ms_universal_event_id', '!=', False)])
|
|
self.assertIn(self.simple_event, synced_events)
|
|
self.assertNotIn(self.simple_event, not_synced_events)
|
|
|
|
self.simple_event.ms_universal_event_id = False
|
|
not_synced_events = self.env['calendar.event'].search([('ms_universal_event_id', '=', False)])
|
|
synced_events = self.env['calendar.event'].search([('ms_universal_event_id', '!=', False)])
|
|
|
|
self.assertNotIn(self.simple_event, synced_events)
|
|
self.assertIn(self.simple_event, not_synced_events)
|
|
|
|
def test_microsoft_event_readonly(self):
|
|
event = MicrosoftEvent()
|
|
with self.assertRaises(TypeError):
|
|
event._events['foo'] = 'bar'
|
|
with self.assertRaises(AttributeError):
|
|
event._events.update({'foo': 'bar'})
|
|
with self.assertRaises(TypeError):
|
|
dict.update(event._events, {'foo': 'bar'})
|
|
|
|
def test_performance_check(self):
|
|
# Test what happens when microsoft returns a lot of data
|
|
# This test does not aim to check what we do with the data but it ensure that we are able to process it.
|
|
# Other tests take care of how we update odoo records with the api result.
|
|
|
|
start_date = datetime(2023, 9, 25, 17, 25)
|
|
record_count = 10000
|
|
single_event_data = [{
|
|
'@odata.type': '#microsoft.graph.event',
|
|
'@odata.etag': f'W/"AAAAAA{x}"',
|
|
'type': 'singleInstance',
|
|
'createdDateTime': (start_date + relativedelta(minutes=x)).isoformat(),
|
|
'lastModifiedDateTime': (datetime.now().astimezone(UTC) + relativedelta(days=3)).isoformat(),
|
|
'changeKey': f'ZS2uEVAVyU6BMZ3m6cH{x}mtgAADI/Dig==',
|
|
'categories': [],
|
|
'originalStartTimeZone': 'Romance Standard Time',
|
|
'originalEndTimeZone': 'Romance Standard Time',
|
|
'id': f'AA{x}',
|
|
'subject': f"Subject of {x}",
|
|
'bodyPreview': f"Body of {x}",
|
|
'start': {'dateTime': (start_date + relativedelta(minutes=x)).isoformat(), 'timeZone': 'UTC'},
|
|
'end': {'dateTime': (start_date + relativedelta(minutes=x)).isoformat(), 'timeZone': 'UTC'},
|
|
'isOrganizer': True,
|
|
'organizer': {'emailAddress': {'name': f'outlook_{x}@outlook.com', 'address': f'outlook_{x}@outlook.com'}},
|
|
} for x in range(record_count)]
|
|
|
|
events = MicrosoftEvent(single_event_data)
|
|
mapped = events._load_odoo_ids_from_db(self.env)
|
|
self.assertFalse(mapped, "No odoo record should correspond to the microsoft values")
|
|
|
|
recurring_event_data = [{
|
|
'@odata.type': '#microsoft.graph.event',
|
|
'@odata.etag': f'W/"{x}IaZKQ=="',
|
|
'createdDateTime': (start_date + relativedelta(minutes=(2*x))).isoformat(),
|
|
'lastModifiedDateTime': (datetime.now().astimezone(UTC) + relativedelta(days=3)).isoformat(),
|
|
'changeKey': 'ZS2uEVAVyU6BMZ3m6cHmtgAADIaZKQ==',
|
|
'categories': [],
|
|
'originalStartTimeZone': 'Romance Standard Time',
|
|
'originalEndTimeZone': 'Romance Standard Time',
|
|
'iCalUId': f'XX{x}',
|
|
'id': f'AAA{x}',
|
|
'reminderMinutesBeforeStart': 15,
|
|
'isReminderOn': True,
|
|
'hasAttachments': False,
|
|
'subject': f'My recurrent event {x}',
|
|
'bodyPreview': '', 'importance':
|
|
'normal', 'sensitivity': 'normal',
|
|
'isAllDay': False, 'isCancelled': False,
|
|
'isOrganizer': True, 'IsRoomRequested': False,
|
|
'AutoRoomBookingStatus': 'None',
|
|
'responseRequested': True,
|
|
'seriesMasterId': None,
|
|
'showAs': 'busy',
|
|
'type': 'seriesMaster',
|
|
'webLink': f'https://outlook.live.com/owa/?itemid={x}&exvsurl=1&path=/calendar/item',
|
|
'onlineMeetingUrl': None,
|
|
'isOnlineMeeting': False,
|
|
'onlineMeetingProvider': 'unknown', 'AllowNewTimeProposals': True,
|
|
'IsDraft': False,
|
|
'responseStatus': {'response': 'organizer', 'time': '0001-01-01T00:00:00Z'},
|
|
'body': {'contentType': 'html', 'content': ''},
|
|
'start': {'dateTime': '2020-05-03T14:30:00.0000000', 'timeZone': 'UTC'},
|
|
'end': {'dateTime': '2020-05-03T16:00:00.0000000', 'timeZone': 'UTC'},
|
|
'location': {'displayName': '',
|
|
'locationType': 'default',
|
|
'uniqueIdType': 'unknown',
|
|
'address': {},
|
|
'coordinates': {}},
|
|
'locations': [],
|
|
'recurrence': {'pattern':
|
|
{'type': 'daily',
|
|
'interval': 1,
|
|
'month': 0,
|
|
'dayOfMonth': 0,
|
|
'firstDayOfWeek': 'sunday',
|
|
'index': 'first'},
|
|
'range': {'type': 'endDate',
|
|
'startDate': '2020-05-03',
|
|
'endDate': '2020-05-05',
|
|
'recurrenceTimeZone': 'Romance Standard Time',
|
|
'numberOfOccurrences': 0}
|
|
},
|
|
'attendees': [],
|
|
'organizer': {'emailAddress': {'name': f'outlook_{x}@outlook.com',
|
|
'address': f'outlook_{x}@outlook.com'}}
|
|
} for x in range(record_count)]
|
|
|
|
recurrences = MicrosoftEvent(recurring_event_data)
|
|
mapped = recurrences._load_odoo_ids_from_db(self.env)
|
|
self.assertFalse(mapped, "No odoo record should correspond to the microsoft values")
|