nextcloud / server

lib/private/Calendar/Manager.php

Indentation +583 added lines, -583 removed lines

@@ -41,587 +41,587 @@
 use function array_merge;
 
 class Manager implements IManager {
-	/**
-	 * @var ICalendar[] holds all registered calendars
-	 */
-	private array $calendars = [];
-
-	/**
-	 * @var \Closure[] to call to load/register calendar providers
-	 */
-	private array $calendarLoaders = [];
-
-	public function __construct(
-		private Coordinator $coordinator,
-		private ContainerInterface $container,
-		private LoggerInterface $logger,
-		private ITimeFactory $timeFactory,
-		private ISecureRandom $random,
-		private IUserManager $userManager,
-		private ServerFactory $serverFactory,
-	) {
-	}
-
-	/**
-	 * This function is used to search and find objects within the user's calendars.
-	 * In case $pattern is empty all events/journals/todos will be returned.
-	 *
-	 * @param string $pattern which should match within the $searchProperties
-	 * @param array $searchProperties defines the properties within the query pattern should match
-	 * @param array $options - optional parameters:
-	 *                       ['timerange' => ['start' => new DateTime(...), 'end' => new DateTime(...)]]
-	 * @param integer|null $limit - limit number of search results
-	 * @param integer|null $offset - offset for paging of search results
-	 * @return array an array of events/journals/todos which are arrays of arrays of key-value-pairs
-	 * @since 13.0.0
-	 */
-	public function search(
-		$pattern,
-		array $searchProperties = [],
-		array $options = [],
-		$limit = null,
-		$offset = null,
-	): array {
-		$this->loadCalendars();
-		$result = [];
-		foreach ($this->calendars as $calendar) {
-			$r = $calendar->search($pattern, $searchProperties, $options, $limit, $offset);
-			foreach ($r as $o) {
-				$o['calendar-key'] = $calendar->getKey();
-				$result[] = $o;
-			}
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Check if calendars are available
-	 *
-	 * @return bool true if enabled, false if not
-	 * @since 13.0.0
-	 */
-	public function isEnabled(): bool {
-		return !empty($this->calendars) || !empty($this->calendarLoaders);
-	}
-
-	/**
-	 * Registers a calendar
-	 *
-	 * @since 13.0.0
-	 */
-	public function registerCalendar(ICalendar $calendar): void {
-		$this->calendars[$calendar->getKey()] = $calendar;
-	}
-
-	/**
-	 * Unregisters a calendar
-	 *
-	 * @since 13.0.0
-	 */
-	public function unregisterCalendar(ICalendar $calendar): void {
-		unset($this->calendars[$calendar->getKey()]);
-	}
-
-	/**
-	 * In order to improve lazy loading a closure can be registered which will be called in case
-	 * calendars are actually requested
-	 *
-	 * @since 13.0.0
-	 */
-	public function register(\Closure $callable): void {
-		$this->calendarLoaders[] = $callable;
-	}
-
-	/**
-	 * @return ICalendar[]
-	 *
-	 * @since 13.0.0
-	 */
-	public function getCalendars(): array {
-		$this->loadCalendars();
-
-		return array_values($this->calendars);
-	}
-
-	/**
-	 * removes all registered calendar instances
-	 *
-	 * @since 13.0.0
-	 */
-	public function clear(): void {
-		$this->calendars = [];
-		$this->calendarLoaders = [];
-	}
-
-	/**
-	 * loads all calendars
-	 */
-	private function loadCalendars(): void {
-		foreach ($this->calendarLoaders as $callable) {
-			$callable($this);
-		}
-		$this->calendarLoaders = [];
-	}
-
-	/**
-	 * @return ICreateFromString[]
-	 */
-	public function getCalendarsForPrincipal(string $principalUri, array $calendarUris = []): array {
-		$context = $this->coordinator->getRegistrationContext();
-		if ($context === null) {
-			return [];
-		}
-
-		return array_merge(
-			...array_map(function ($registration) use ($principalUri, $calendarUris) {
-				try {
-					/** @var ICalendarProvider $provider */
-					$provider = $this->container->get($registration->getService());
-				} catch (Throwable $e) {
-					$this->logger->error('Could not load calendar provider ' . $registration->getService() . ': ' . $e->getMessage(), [
-						'exception' => $e,
-					]);
-					return [];
-				}
-
-				return $provider->getCalendars($principalUri, $calendarUris);
-			}, $context->getCalendarProviders())
-		);
-	}
-
-	public function searchForPrincipal(ICalendarQuery $query): array {
-		/** @var CalendarQuery $query */
-		$calendars = $this->getCalendarsForPrincipal(
-			$query->getPrincipalUri(),
-			$query->getCalendarUris(),
-		);
-
-		$results = [];
-		foreach ($calendars as $calendar) {
-			$r = $calendar->search(
-				$query->getSearchPattern() ?? '',
-				$query->getSearchProperties(),
-				$query->getOptions(),
-				$query->getLimit(),
-				$query->getOffset()
-			);
-
-			foreach ($r as $o) {
-				$o['calendar-key'] = $calendar->getKey();
-				$o['calendar-uri'] = $calendar->getUri();
-				$results[] = $o;
-			}
-		}
-		return $results;
-	}
-
-	public function newQuery(string $principalUri): ICalendarQuery {
-		return new CalendarQuery($principalUri);
-	}
-
-	/**
-	 * @since 31.0.0
-	 * @throws \OCP\DB\Exception
-	 */
-	public function handleIMipRequest(
-		string $principalUri,
-		string $sender,
-		string $recipient,
-		string $calendarData,
-	): bool {
-
-		$userCalendars = $this->getCalendarsForPrincipal($principalUri);
-		if (empty($userCalendars)) {
-			$this->logger->warning('iMip message could not be processed because user has no calendars');
-			return false;
-		}
-
-		try {
-			/** @var VCalendar $vObject|null */
-			$calendarObject = Reader::read($calendarData);
-		} catch (ParseException $e) {
-			$this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
-			return false;
-		}
-
-		if (!isset($calendarObject->METHOD) || $calendarObject->METHOD->getValue() !== 'REQUEST') {
-			$this->logger->warning('iMip message contains an incorrect or invalid method');
-			return false;
-		}
-
-		if (!isset($calendarObject->VEVENT)) {
-			$this->logger->warning('iMip message contains no event');
-			return false;
-		}
-
-		/** @var VEvent|null $vEvent */
-		$eventObject = $calendarObject->VEVENT;
-
-		if (!isset($eventObject->UID)) {
-			$this->logger->warning('iMip message event dose not contains a UID');
-			return false;
-		}
-
-		if (!isset($eventObject->ORGANIZER)) {
-			$this->logger->warning('iMip message event dose not contains an organizer');
-			return false;
-		}
-
-		if (!isset($eventObject->ATTENDEE)) {
-			$this->logger->warning('iMip message event dose not contains any attendees');
-			return false;
-		}
-
-		foreach ($eventObject->ATTENDEE as $entry) {
-			$address = trim(str_replace('mailto:', '', $entry->getValue()));
-			if ($address === $recipient) {
-				$attendee = $address;
-				break;
-			}
-		}
-		if (!isset($attendee)) {
-			$this->logger->warning('iMip message event does not contain a attendee that matches the recipient');
-			return false;
-		}
-
-		foreach ($userCalendars as $calendar) {
-
-			if (!$calendar instanceof ICalendarIsWritable && !$calendar instanceof ICalendarIsShared) {
-				continue;
-			}
-
-			if ($calendar->isDeleted() || !$calendar->isWritable() || $calendar->isShared()) {
-				continue;
-			}
-
-			if (!empty($calendar->search($recipient, ['ATTENDEE'], ['uid' => $eventObject->UID->getValue()]))) {
-				try {
-					if ($calendar instanceof IHandleImipMessage) {
-						$calendar->handleIMipMessage('', $calendarData);
-					}
-					return true;
-				} catch (CalendarException $e) {
-					$this->logger->error('An error occurred while processing the iMip message event', ['exception' => $e]);
-					return false;
-				}
-			}
-		}
-
-		$this->logger->warning('iMip message event could not be processed because no corresponding event was found in any calendar');
-		return false;
-	}
-
-	/**
-	 * @throws \OCP\DB\Exception
-	 */
-	public function handleIMipReply(
-		string $principalUri,
-		string $sender,
-		string $recipient,
-		string $calendarData,
-	): bool {
-
-		$calendars = $this->getCalendarsForPrincipal($principalUri);
-		if (empty($calendars)) {
-			$this->logger->warning('iMip message could not be processed because user has no calendars');
-			return false;
-		}
-
-		try {
-			/** @var VCalendar $vObject|null */
-			$vObject = Reader::read($calendarData);
-		} catch (ParseException $e) {
-			$this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
-			return false;
-		}
-
-		if ($vObject === null) {
-			$this->logger->warning('iMip message contains an invalid calendar object');
-			return false;
-		}
-
-		if (!isset($vObject->METHOD) || $vObject->METHOD->getValue() !== 'REPLY') {
-			$this->logger->warning('iMip message contains an incorrect or invalid method');
-			return false;
-		}
-
-		if (!isset($vObject->VEVENT)) {
-			$this->logger->warning('iMip message contains no event');
-			return false;
-		}
-
-		/** @var VEvent|null $vEvent */
-		$vEvent = $vObject->VEVENT;
-
-		if (!isset($vEvent->UID)) {
-			$this->logger->warning('iMip message event dose not contains a UID');
-			return false;
-		}
-
-		if (!isset($vEvent->ORGANIZER)) {
-			$this->logger->warning('iMip message event dose not contains an organizer');
-			return false;
-		}
-
-		if (!isset($vEvent->ATTENDEE)) {
-			$this->logger->warning('iMip message event dose not contains any attendees');
-			return false;
-		}
-
-		// check if mail recipient and organizer are one and the same
-		$organizer = substr($vEvent->{'ORGANIZER'}->getValue(), 7);
-
-		if (strcasecmp($recipient, $organizer) !== 0) {
-			$this->logger->warning('iMip message event could not be processed because recipient and ORGANIZER must be identical');
-			return false;
-		}
-
-		//check if the event is in the future
-		/** @var DateTime $eventTime */
-		$eventTime = $vEvent->{'DTSTART'};
-		if ($eventTime->getDateTime()->getTimeStamp() < $this->timeFactory->getTime()) { // this might cause issues with recurrences
-			$this->logger->warning('iMip message event could not be processed because the event is in the past');
-			return false;
-		}
-
-		$found = null;
-		// if the attendee has been found in at least one calendar event with the UID of the iMIP event
-		// we process it.
-		// Benefit: no attendee lost
-		// Drawback: attendees that have been deleted will still be able to update their partstat
-		foreach ($calendars as $calendar) {
-			// We should not search in writable calendars
-			if ($calendar instanceof IHandleImipMessage) {
-				$o = $calendar->search($sender, ['ATTENDEE'], ['uid' => $vEvent->{'UID'}->getValue()]);
-				if (!empty($o)) {
-					$found = $calendar;
-					$name = $o[0]['uri'];
-					break;
-				}
-			}
-		}
-
-		if (empty($found)) {
-			$this->logger->warning('iMip message event could not be processed because no corresponding event was found in any calendar', [
-				'principalUri' => $principalUri,
-				'eventUid' => $vEvent->{'UID'}->getValue(),
-			]);
-			return false;
-		}
-
-		try {
-			$found->handleIMipMessage($name, $calendarData); // sabre will handle the scheduling behind the scenes
-		} catch (CalendarException $e) {
-			$this->logger->error('An error occurred while processing the iMip message event', ['exception' => $e]);
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * @since 25.0.0
-	 * @throws \OCP\DB\Exception
-	 */
-	public function handleIMipCancel(
-		string $principalUri,
-		string $sender,
-		?string $replyTo,
-		string $recipient,
-		string $calendarData,
-	): bool {
-
-		$calendars = $this->getCalendarsForPrincipal($principalUri);
-		if (empty($calendars)) {
-			$this->logger->warning('iMip message could not be processed because user has no calendars');
-			return false;
-		}
-
-		try {
-			/** @var VCalendar $vObject|null */
-			$vObject = Reader::read($calendarData);
-		} catch (ParseException $e) {
-			$this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
-			return false;
-		}
-
-		if ($vObject === null) {
-			$this->logger->warning('iMip message contains an invalid calendar object');
-			return false;
-		}
-
-		if (!isset($vObject->METHOD) || $vObject->METHOD->getValue() !== 'CANCEL') {
-			$this->logger->warning('iMip message contains an incorrect or invalid method');
-			return false;
-		}
-
-		if (!isset($vObject->VEVENT)) {
-			$this->logger->warning('iMip message contains no event');
-			return false;
-		}
-
-		/** @var VEvent|null $vEvent */
-		$vEvent = $vObject->{'VEVENT'};
-
-		if (!isset($vEvent->UID)) {
-			$this->logger->warning('iMip message event dose not contains a UID');
-			return false;
-		}
-
-		if (!isset($vEvent->ORGANIZER)) {
-			$this->logger->warning('iMip message event dose not contains an organizer');
-			return false;
-		}
-
-		if (!isset($vEvent->ATTENDEE)) {
-			$this->logger->warning('iMip message event dose not contains any attendees');
-			return false;
-		}
-
-		$attendee = substr($vEvent->{'ATTENDEE'}->getValue(), 7);
-		if (strcasecmp($recipient, $attendee) !== 0) {
-			$this->logger->warning('iMip message event could not be processed because recipient must be an ATTENDEE of this event');
-			return false;
-		}
-
-		// Thirdly, we need to compare the email address the CANCEL is coming from (in Mail)
-		// or the Reply- To Address submitted with the CANCEL email
-		// to the email address in the ORGANIZER.
-		// We don't want to accept a CANCEL request from just anyone
-		$organizer = substr($vEvent->{'ORGANIZER'}->getValue(), 7);
-		$isNotOrganizer = ($replyTo !== null) ? (strcasecmp($sender, $organizer) !== 0 && strcasecmp($replyTo, $organizer) !== 0) : (strcasecmp($sender, $organizer) !== 0);
-		if ($isNotOrganizer) {
-			$this->logger->warning('iMip message event could not be processed because sender must be the ORGANIZER of this event');
-			return false;
-		}
-
-		//check if the event is in the future
-		/** @var DateTime $eventTime */
-		$eventTime = $vEvent->{'DTSTART'};
-		if ($eventTime->getDateTime()->getTimeStamp() < $this->timeFactory->getTime()) { // this might cause issues with recurrences
-			$this->logger->warning('iMip message event could not be processed because the event is in the past');
-			return false;
-		}
-
-		$found = null;
-		// if the attendee has been found in at least one calendar event with the UID of the iMIP event
-		// we process it.
-		// Benefit: no attendee lost
-		// Drawback: attendees that have been deleted will still be able to update their partstat
-		foreach ($calendars as $calendar) {
-			// We should not search in writable calendars
-			if ($calendar instanceof IHandleImipMessage) {
-				$o = $calendar->search($recipient, ['ATTENDEE'], ['uid' => $vEvent->{'UID'}->getValue()]);
-				if (!empty($o)) {
-					$found = $calendar;
-					$name = $o[0]['uri'];
-					break;
-				}
-			}
-		}
-
-		if (empty($found)) {
-			$this->logger->warning('iMip message event could not be processed because no corresponding event was found in any calendar', [
-				'principalUri' => $principalUri,
-				'eventUid' => $vEvent->{'UID'}->getValue(),
-			]);
-			return false;
-		}
-
-		try {
-			$found->handleIMipMessage($name, $calendarData); // sabre will handle the scheduling behind the scenes
-			return true;
-		} catch (CalendarException $e) {
-			$this->logger->error('An error occurred while processing the iMip message event', ['exception' => $e]);
-			return false;
-		}
-	}
-
-	public function createEventBuilder(): ICalendarEventBuilder {
-		$uid = $this->random->generate(32, ISecureRandom::CHAR_ALPHANUMERIC);
-		return new CalendarEventBuilder($uid, $this->timeFactory);
-	}
-
-	public function checkAvailability(
-		DateTimeInterface $start,
-		DateTimeInterface $end,
-		IUser $organizer,
-		array $attendees,
-	): array {
-		$organizerMailto = 'mailto:' . $organizer->getEMailAddress();
-		$request = new VCalendar();
-		$request->METHOD = 'REQUEST';
-		$request->add('VFREEBUSY', [
-			'DTSTART' => $start,
-			'DTEND' => $end,
-			'ORGANIZER' => $organizerMailto,
-			'ATTENDEE' => $organizerMailto,
-		]);
-
-		$mailtoLen = strlen('mailto:');
-		foreach ($attendees as $attendee) {
-			if (str_starts_with($attendee, 'mailto:')) {
-				$attendee = substr($attendee, $mailtoLen);
-			}
-
-			$attendeeUsers = $this->userManager->getByEmail($attendee);
-			if ($attendeeUsers === []) {
-				continue;
-			}
-
-			$request->VFREEBUSY->add('ATTENDEE', "mailto:$attendee");
-		}
-
-		$organizerUid = $organizer->getUID();
-		$server = $this->serverFactory->createAttendeeAvailabilityServer();
-		/** @var CustomPrincipalPlugin $plugin */
-		$plugin = $server->getPlugin('auth');
-		$plugin->setCurrentPrincipal("principals/users/$organizerUid");
-
-		$request = new Request(
-			'POST',
-			"/calendars/$organizerUid/outbox/",
-			[
-				'Content-Type' => 'text/calendar',
-				'Depth' => 0,
-			],
-			$request->serialize(),
-		);
-		$response = new Response();
-		$server->invokeMethod($request, $response, false);
-
-		$xmlService = new \Sabre\Xml\Service();
-		$xmlService->elementMap = [
-			'{urn:ietf:params:xml:ns:caldav}response' => 'Sabre\Xml\Deserializer\keyValue',
-			'{urn:ietf:params:xml:ns:caldav}recipient' => 'Sabre\Xml\Deserializer\keyValue',
-		];
-		$parsedResponse = $xmlService->parse($response->getBodyAsString());
-
-		$result = [];
-		foreach ($parsedResponse as $freeBusyResponse) {
-			$freeBusyResponse = $freeBusyResponse['value'];
-			if ($freeBusyResponse['{urn:ietf:params:xml:ns:caldav}request-status'] !== '2.0;Success') {
-				continue;
-			}
-
-			$freeBusyResponseData = \Sabre\VObject\Reader::read(
-				$freeBusyResponse['{urn:ietf:params:xml:ns:caldav}calendar-data']
-			);
-
-			$attendee = substr(
-				$freeBusyResponse['{urn:ietf:params:xml:ns:caldav}recipient']['{DAV:}href'],
-				$mailtoLen,
-			);
-
-			$vFreeBusy = $freeBusyResponseData->VFREEBUSY;
-			if (!($vFreeBusy instanceof VFreeBusy)) {
-				continue;
-			}
-
-			// TODO: actually check values of FREEBUSY properties to find a free slot
-			$result[] = new AvailabilityResult($attendee, $vFreeBusy->isFree($start, $end));
-		}
-
-		return $result;
-	}
+    /**
+     * @var ICalendar[] holds all registered calendars
+     */
+    private array $calendars = [];
+
+    /**
+     * @var \Closure[] to call to load/register calendar providers
+     */
+    private array $calendarLoaders = [];
+
+    public function __construct(
+        private Coordinator $coordinator,
+        private ContainerInterface $container,
+        private LoggerInterface $logger,
+        private ITimeFactory $timeFactory,
+        private ISecureRandom $random,
+        private IUserManager $userManager,
+        private ServerFactory $serverFactory,
+    ) {
+    }
+
+    /**
+     * This function is used to search and find objects within the user's calendars.
+     * In case $pattern is empty all events/journals/todos will be returned.
+     *
+     * @param string $pattern which should match within the $searchProperties
+     * @param array $searchProperties defines the properties within the query pattern should match
+     * @param array $options - optional parameters:
+     *                       ['timerange' => ['start' => new DateTime(...), 'end' => new DateTime(...)]]
+     * @param integer|null $limit - limit number of search results
+     * @param integer|null $offset - offset for paging of search results
+     * @return array an array of events/journals/todos which are arrays of arrays of key-value-pairs
+     * @since 13.0.0
+     */
+    public function search(
+        $pattern,
+        array $searchProperties = [],
+        array $options = [],
+        $limit = null,
+        $offset = null,
+    ): array {
+        $this->loadCalendars();
+        $result = [];
+        foreach ($this->calendars as $calendar) {
+            $r = $calendar->search($pattern, $searchProperties, $options, $limit, $offset);
+            foreach ($r as $o) {
+                $o['calendar-key'] = $calendar->getKey();
+                $result[] = $o;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Check if calendars are available
+     *
+     * @return bool true if enabled, false if not
+     * @since 13.0.0
+     */
+    public function isEnabled(): bool {
+        return !empty($this->calendars) || !empty($this->calendarLoaders);
+    }
+
+    /**
+     * Registers a calendar
+     *
+     * @since 13.0.0
+     */
+    public function registerCalendar(ICalendar $calendar): void {
+        $this->calendars[$calendar->getKey()] = $calendar;
+    }
+
+    /**
+     * Unregisters a calendar
+     *
+     * @since 13.0.0
+     */
+    public function unregisterCalendar(ICalendar $calendar): void {
+        unset($this->calendars[$calendar->getKey()]);
+    }
+
+    /**
+     * In order to improve lazy loading a closure can be registered which will be called in case
+     * calendars are actually requested
+     *
+     * @since 13.0.0
+     */
+    public function register(\Closure $callable): void {
+        $this->calendarLoaders[] = $callable;
+    }
+
+    /**
+     * @return ICalendar[]
+     *
+     * @since 13.0.0
+     */
+    public function getCalendars(): array {
+        $this->loadCalendars();
+
+        return array_values($this->calendars);
+    }
+
+    /**
+     * removes all registered calendar instances
+     *
+     * @since 13.0.0
+     */
+    public function clear(): void {
+        $this->calendars = [];
+        $this->calendarLoaders = [];
+    }
+
+    /**
+     * loads all calendars
+     */
+    private function loadCalendars(): void {
+        foreach ($this->calendarLoaders as $callable) {
+            $callable($this);
+        }
+        $this->calendarLoaders = [];
+    }
+
+    /**
+     * @return ICreateFromString[]
+     */
+    public function getCalendarsForPrincipal(string $principalUri, array $calendarUris = []): array {
+        $context = $this->coordinator->getRegistrationContext();
+        if ($context === null) {
+            return [];
+        }
+
+        return array_merge(
+            ...array_map(function ($registration) use ($principalUri, $calendarUris) {
+                try {
+                    /** @var ICalendarProvider $provider */
+                    $provider = $this->container->get($registration->getService());
+                } catch (Throwable $e) {
+                    $this->logger->error('Could not load calendar provider ' . $registration->getService() . ': ' . $e->getMessage(), [
+                        'exception' => $e,
+                    ]);
+                    return [];
+                }
+
+                return $provider->getCalendars($principalUri, $calendarUris);
+            }, $context->getCalendarProviders())
+        );
+    }
+
+    public function searchForPrincipal(ICalendarQuery $query): array {
+        /** @var CalendarQuery $query */
+        $calendars = $this->getCalendarsForPrincipal(
+            $query->getPrincipalUri(),
+            $query->getCalendarUris(),
+        );
+
+        $results = [];
+        foreach ($calendars as $calendar) {
+            $r = $calendar->search(
+                $query->getSearchPattern() ?? '',
+                $query->getSearchProperties(),
+                $query->getOptions(),
+                $query->getLimit(),
+                $query->getOffset()
+            );
+
+            foreach ($r as $o) {
+                $o['calendar-key'] = $calendar->getKey();
+                $o['calendar-uri'] = $calendar->getUri();
+                $results[] = $o;
+            }
+        }
+        return $results;
+    }
+
+    public function newQuery(string $principalUri): ICalendarQuery {
+        return new CalendarQuery($principalUri);
+    }
+
+    /**
+     * @since 31.0.0
+     * @throws \OCP\DB\Exception
+     */
+    public function handleIMipRequest(
+        string $principalUri,
+        string $sender,
+        string $recipient,
+        string $calendarData,
+    ): bool {
+
+        $userCalendars = $this->getCalendarsForPrincipal($principalUri);
+        if (empty($userCalendars)) {
+            $this->logger->warning('iMip message could not be processed because user has no calendars');
+            return false;
+        }
+
+        try {
+            /** @var VCalendar $vObject|null */
+            $calendarObject = Reader::read($calendarData);
+        } catch (ParseException $e) {
+            $this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
+            return false;
+        }
+
+        if (!isset($calendarObject->METHOD) || $calendarObject->METHOD->getValue() !== 'REQUEST') {
+            $this->logger->warning('iMip message contains an incorrect or invalid method');
+            return false;
+        }
+
+        if (!isset($calendarObject->VEVENT)) {
+            $this->logger->warning('iMip message contains no event');
+            return false;
+        }
+
+        /** @var VEvent|null $vEvent */
+        $eventObject = $calendarObject->VEVENT;
+
+        if (!isset($eventObject->UID)) {
+            $this->logger->warning('iMip message event dose not contains a UID');
+            return false;
+        }
+
+        if (!isset($eventObject->ORGANIZER)) {
+            $this->logger->warning('iMip message event dose not contains an organizer');
+            return false;
+        }
+
+        if (!isset($eventObject->ATTENDEE)) {
+            $this->logger->warning('iMip message event dose not contains any attendees');
+            return false;
+        }
+
+        foreach ($eventObject->ATTENDEE as $entry) {
+            $address = trim(str_replace('mailto:', '', $entry->getValue()));
+            if ($address === $recipient) {
+                $attendee = $address;
+                break;
+            }
+        }
+        if (!isset($attendee)) {
+            $this->logger->warning('iMip message event does not contain a attendee that matches the recipient');
+            return false;
+        }
+
+        foreach ($userCalendars as $calendar) {
+
+            if (!$calendar instanceof ICalendarIsWritable && !$calendar instanceof ICalendarIsShared) {
+                continue;
+            }
+
+            if ($calendar->isDeleted() || !$calendar->isWritable() || $calendar->isShared()) {
+                continue;
+            }
+
+            if (!empty($calendar->search($recipient, ['ATTENDEE'], ['uid' => $eventObject->UID->getValue()]))) {
+                try {
+                    if ($calendar instanceof IHandleImipMessage) {
+                        $calendar->handleIMipMessage('', $calendarData);
+                    }
+                    return true;
+                } catch (CalendarException $e) {
+                    $this->logger->error('An error occurred while processing the iMip message event', ['exception' => $e]);
+                    return false;
+                }
+            }
+        }
+
+        $this->logger->warning('iMip message event could not be processed because no corresponding event was found in any calendar');
+        return false;
+    }
+
+    /**
+     * @throws \OCP\DB\Exception
+     */
+    public function handleIMipReply(
+        string $principalUri,
+        string $sender,
+        string $recipient,
+        string $calendarData,
+    ): bool {
+
+        $calendars = $this->getCalendarsForPrincipal($principalUri);
+        if (empty($calendars)) {
+            $this->logger->warning('iMip message could not be processed because user has no calendars');
+            return false;
+        }
+
+        try {
+            /** @var VCalendar $vObject|null */
+            $vObject = Reader::read($calendarData);
+        } catch (ParseException $e) {
+            $this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
+            return false;
+        }
+
+        if ($vObject === null) {
+            $this->logger->warning('iMip message contains an invalid calendar object');
+            return false;
+        }
+
+        if (!isset($vObject->METHOD) || $vObject->METHOD->getValue() !== 'REPLY') {
+            $this->logger->warning('iMip message contains an incorrect or invalid method');
+            return false;
+        }
+
+        if (!isset($vObject->VEVENT)) {
+            $this->logger->warning('iMip message contains no event');
+            return false;
+        }
+
+        /** @var VEvent|null $vEvent */
+        $vEvent = $vObject->VEVENT;
+
+        if (!isset($vEvent->UID)) {
+            $this->logger->warning('iMip message event dose not contains a UID');
+            return false;
+        }
+
+        if (!isset($vEvent->ORGANIZER)) {
+            $this->logger->warning('iMip message event dose not contains an organizer');
+            return false;
+        }
+
+        if (!isset($vEvent->ATTENDEE)) {
+            $this->logger->warning('iMip message event dose not contains any attendees');
+            return false;
+        }
+
+        // check if mail recipient and organizer are one and the same
+        $organizer = substr($vEvent->{'ORGANIZER'}->getValue(), 7);
+
+        if (strcasecmp($recipient, $organizer) !== 0) {
+            $this->logger->warning('iMip message event could not be processed because recipient and ORGANIZER must be identical');
+            return false;
+        }
+
+        //check if the event is in the future
+        /** @var DateTime $eventTime */
+        $eventTime = $vEvent->{'DTSTART'};
+        if ($eventTime->getDateTime()->getTimeStamp() < $this->timeFactory->getTime()) { // this might cause issues with recurrences
+            $this->logger->warning('iMip message event could not be processed because the event is in the past');
+            return false;
+        }
+
+        $found = null;
+        // if the attendee has been found in at least one calendar event with the UID of the iMIP event
+        // we process it.
+        // Benefit: no attendee lost
+        // Drawback: attendees that have been deleted will still be able to update their partstat
+        foreach ($calendars as $calendar) {
+            // We should not search in writable calendars
+            if ($calendar instanceof IHandleImipMessage) {
+                $o = $calendar->search($sender, ['ATTENDEE'], ['uid' => $vEvent->{'UID'}->getValue()]);
+                if (!empty($o)) {
+                    $found = $calendar;
+                    $name = $o[0]['uri'];
+                    break;
+                }
+            }
+        }
+
+        if (empty($found)) {
+            $this->logger->warning('iMip message event could not be processed because no corresponding event was found in any calendar', [
+                'principalUri' => $principalUri,
+                'eventUid' => $vEvent->{'UID'}->getValue(),
+            ]);
+            return false;
+        }
+
+        try {
+            $found->handleIMipMessage($name, $calendarData); // sabre will handle the scheduling behind the scenes
+        } catch (CalendarException $e) {
+            $this->logger->error('An error occurred while processing the iMip message event', ['exception' => $e]);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @since 25.0.0
+     * @throws \OCP\DB\Exception
+     */
+    public function handleIMipCancel(
+        string $principalUri,
+        string $sender,
+        ?string $replyTo,
+        string $recipient,
+        string $calendarData,
+    ): bool {
+
+        $calendars = $this->getCalendarsForPrincipal($principalUri);
+        if (empty($calendars)) {
+            $this->logger->warning('iMip message could not be processed because user has no calendars');
+            return false;
+        }
+
+        try {
+            /** @var VCalendar $vObject|null */
+            $vObject = Reader::read($calendarData);
+        } catch (ParseException $e) {
+            $this->logger->error('iMip message could not be processed because an error occurred while parsing the iMip message', ['exception' => $e]);
+            return false;
+        }
+
+        if ($vObject === null) {
+            $this->logger->warning('iMip message contains an invalid calendar object');
+            return false;
+        }
+
+        if (!isset($vObject->METHOD) || $vObject->METHOD->getValue() !== 'CANCEL') {
+            $this->logger->warning('iMip message contains an incorrect or invalid method');
+            return false;
+        }
+
+        if (!isset($vObject->VEVENT)) {
+            $this->logger->warning('iMip message contains no event');
+            return false;
+        }
+
+        /** @var VEvent|null $vEvent */
+        $vEvent = $vObject->{'VEVENT'};
+
+        if (!isset($vEvent->UID)) {
+            $this->logger->warning('iMip message event dose not contains a UID');
+            return false;
+        }
+
+        if (!isset($vEvent->ORGANIZER)) {
+            $this->logger->warning('iMip message event dose not contains an organizer');
+            return false;
+        }
+
+        if (!isset($vEvent->ATTENDEE)) {
+            $this->logger->warning('iMip message event dose not contains any attendees');
+            return false;
+        }
+
+        $attendee = substr($vEvent->{'ATTENDEE'}->getValue(), 7);
+        if (strcasecmp($recipient, $attendee) !== 0) {
+            $this->logger->warning('iMip message event could not be processed because recipient must be an ATTENDEE of this event');
+            return false;
+        }
+
+        // Thirdly, we need to compare the email address the CANCEL is coming from (in Mail)
+        // or the Reply- To Address submitted with the CANCEL email
+        // to the email address in the ORGANIZER.
+        // We don't want to accept a CANCEL request from just anyone
+        $organizer = substr($vEvent->{'ORGANIZER'}->getValue(), 7);
+        $isNotOrganizer = ($replyTo !== null) ? (strcasecmp($sender, $organizer) !== 0 && strcasecmp($replyTo, $organizer) !== 0) : (strcasecmp($sender, $organizer) !== 0);
+        if ($isNotOrganizer) {
+            $this->logger->warning('iMip message event could not be processed because sender must be the ORGANIZER of this event');
+            return false;
+        }
+
+        //check if the event is in the future
+        /** @var DateTime $eventTime */
+        $eventTime = $vEvent->{'DTSTART'};
+        if ($eventTime->getDateTime()->getTimeStamp() < $this->timeFactory->getTime()) { // this might cause issues with recurrences
+            $this->logger->warning('iMip message event could not be processed because the event is in the past');
+            return false;
+        }
+
+        $found = null;
+        // if the attendee has been found in at least one calendar event with the UID of the iMIP event
+        // we process it.
+        // Benefit: no attendee lost
+        // Drawback: attendees that have been deleted will still be able to update their partstat
+        foreach ($calendars as $calendar) {
+            // We should not search in writable calendars
+            if ($calendar instanceof IHandleImipMessage) {
+                $o = $calendar->search($recipient, ['ATTENDEE'], ['uid' => $vEvent->{'UID'}->getValue()]);
+                if (!empty($o)) {
+                    $found = $calendar;
+                    $name = $o[0]['uri'];
+                    break;
+                }
+            }
+        }
+
+        if (empty($found)) {
+            $this->logger->warning('iMip message event could not be processed because no corresponding event was found in any calendar', [
+                'principalUri' => $principalUri,
+                'eventUid' => $vEvent->{'UID'}->getValue(),
+            ]);
+            return false;
+        }
+
+        try {
+            $found->handleIMipMessage($name, $calendarData); // sabre will handle the scheduling behind the scenes
+            return true;
+        } catch (CalendarException $e) {
+            $this->logger->error('An error occurred while processing the iMip message event', ['exception' => $e]);
+            return false;
+        }
+    }
+
+    public function createEventBuilder(): ICalendarEventBuilder {
+        $uid = $this->random->generate(32, ISecureRandom::CHAR_ALPHANUMERIC);
+        return new CalendarEventBuilder($uid, $this->timeFactory);
+    }
+
+    public function checkAvailability(
+        DateTimeInterface $start,
+        DateTimeInterface $end,
+        IUser $organizer,
+        array $attendees,
+    ): array {
+        $organizerMailto = 'mailto:' . $organizer->getEMailAddress();
+        $request = new VCalendar();
+        $request->METHOD = 'REQUEST';
+        $request->add('VFREEBUSY', [
+            'DTSTART' => $start,
+            'DTEND' => $end,
+            'ORGANIZER' => $organizerMailto,
+            'ATTENDEE' => $organizerMailto,
+        ]);
+
+        $mailtoLen = strlen('mailto:');
+        foreach ($attendees as $attendee) {
+            if (str_starts_with($attendee, 'mailto:')) {
+                $attendee = substr($attendee, $mailtoLen);
+            }
+
+            $attendeeUsers = $this->userManager->getByEmail($attendee);
+            if ($attendeeUsers === []) {
+                continue;
+            }
+
+            $request->VFREEBUSY->add('ATTENDEE', "mailto:$attendee");
+        }
+
+        $organizerUid = $organizer->getUID();
+        $server = $this->serverFactory->createAttendeeAvailabilityServer();
+        /** @var CustomPrincipalPlugin $plugin */
+        $plugin = $server->getPlugin('auth');
+        $plugin->setCurrentPrincipal("principals/users/$organizerUid");
+
+        $request = new Request(
+            'POST',
+            "/calendars/$organizerUid/outbox/",
+            [
+                'Content-Type' => 'text/calendar',
+                'Depth' => 0,
+            ],
+            $request->serialize(),
+        );
+        $response = new Response();
+        $server->invokeMethod($request, $response, false);
+
+        $xmlService = new \Sabre\Xml\Service();
+        $xmlService->elementMap = [
+            '{urn:ietf:params:xml:ns:caldav}response' => 'Sabre\Xml\Deserializer\keyValue',
+            '{urn:ietf:params:xml:ns:caldav}recipient' => 'Sabre\Xml\Deserializer\keyValue',
+        ];
+        $parsedResponse = $xmlService->parse($response->getBodyAsString());
+
+        $result = [];
+        foreach ($parsedResponse as $freeBusyResponse) {
+            $freeBusyResponse = $freeBusyResponse['value'];
+            if ($freeBusyResponse['{urn:ietf:params:xml:ns:caldav}request-status'] !== '2.0;Success') {
+                continue;
+            }
+
+            $freeBusyResponseData = \Sabre\VObject\Reader::read(
+                $freeBusyResponse['{urn:ietf:params:xml:ns:caldav}calendar-data']
+            );
+
+            $attendee = substr(
+                $freeBusyResponse['{urn:ietf:params:xml:ns:caldav}recipient']['{DAV:}href'],
+                $mailtoLen,
+            );
+
+            $vFreeBusy = $freeBusyResponseData->VFREEBUSY;
+            if (!($vFreeBusy instanceof VFreeBusy)) {
+                continue;
+            }
+
+            // TODO: actually check values of FREEBUSY properties to find a free slot
+            $result[] = new AvailabilityResult($attendee, $vFreeBusy->isFree($start, $end));
+        }
+
+        return $result;
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -174,12 +174,12 @@ 
 		}
 
 		return array_merge(
-			...array_map(function ($registration) use ($principalUri, $calendarUris) {
+			...array_map(function($registration) use ($principalUri, $calendarUris) {
 				try {
 					/** @var ICalendarProvider $provider */
 					$provider = $this->container->get($registration->getService());
 				} catch (Throwable $e) {
-					$this->logger->error('Could not load calendar provider ' . $registration->getService() . ': ' . $e->getMessage(), [
+					$this->logger->error('Could not load calendar provider '.$registration->getService().': '.$e->getMessage(), [
 						'exception' => $e,
 					]);
 					return [];
@@ -548,7 +548,7 @@ 
 		IUser $organizer,
 		array $attendees,
 	): array {
-		$organizerMailto = 'mailto:' . $organizer->getEMailAddress();
+		$organizerMailto = 'mailto:'.$organizer->getEMailAddress();
 		$request = new VCalendar();
 		$request->METHOD = 'REQUEST';
 		$request->add('VFREEBUSY', [

tests/lib/Calendar/ManagerTest.php

Indentation +1716 added lines, -1716 removed lines

@@ -38,1587 +38,1587 @@ 
 }
 
 class ManagerTest extends TestCase {
-	/** @var Coordinator&MockObject */
-	private $coordinator;
-
-	/** @var ContainerInterface&MockObject */
-	private $container;
-
-	/** @var LoggerInterface&MockObject */
-	private $logger;
-
-	/** @var Manager */
-	private $manager;
-
-	/** @var ITimeFactory&MockObject */
-	private $time;
-
-	/** @var ISecureRandom&MockObject */
-	private ISecureRandom $secureRandom;
-
-	private IUserManager&MockObject $userManager;
-	private ServerFactory&MockObject $serverFactory;
-
-	private VCalendar $vCalendar1a;
-	private VCalendar $vCalendar2a;
-	private VCalendar $vCalendar3a;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->coordinator = $this->createMock(Coordinator::class);
-		$this->container = $this->createMock(ContainerInterface::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->time = $this->createMock(ITimeFactory::class);
-		$this->secureRandom = $this->createMock(ISecureRandom::class);
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->serverFactory = $this->createMock(ServerFactory::class);
-
-		$this->manager = new Manager(
-			$this->coordinator,
-			$this->container,
-			$this->logger,
-			$this->time,
-			$this->secureRandom,
-			$this->userManager,
-			$this->serverFactory,
-		);
-
-		// construct calendar with a 1 hour event and same start/end time zones
-		$this->vCalendar1a = new VCalendar();
-		/** @var VEvent $vEvent */
-		$vEvent = $this->vCalendar1a->add('VEVENT', []);
-		$vEvent->UID->setValue('96a0e6b1-d886-4a55-a60d-152b31401dcc');
-		$vEvent->add('DTSTART', '20240701T080000', ['TZID' => 'America/Toronto']);
-		$vEvent->add('DTEND', '20240701T090000', ['TZID' => 'America/Toronto']);
-		$vEvent->add('SUMMARY', 'Test Event');
-		$vEvent->add('SEQUENCE', 3);
-		$vEvent->add('STATUS', 'CONFIRMED');
-		$vEvent->add('TRANSP', 'OPAQUE');
-		$vEvent->add('ORGANIZER', 'mailto:organizer@testing.com', ['CN' => 'Organizer']);
-		$vEvent->add('ATTENDEE', 'mailto:attendee1@testing.com', [
-			'CN' => 'Attendee One',
-			'CUTYPE' => 'INDIVIDUAL',
-			'PARTSTAT' => 'NEEDS-ACTION',
-			'ROLE' => 'REQ-PARTICIPANT',
-			'RSVP' => 'TRUE'
-		]);
-
-		// construct calendar with a event for reply
-		$this->vCalendar2a = new VCalendar();
-		/** @var VEvent $vEvent */
-		$vEvent = $this->vCalendar2a->add('VEVENT', []);
-		$vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
-		$vEvent->add('DTSTART', '20210820');
-		$vEvent->add('DTEND', '20220821');
-		$vEvent->add('SUMMARY', 'berry basket');
-		$vEvent->add('SEQUENCE', 3);
-		$vEvent->add('STATUS', 'CONFIRMED');
-		$vEvent->add('TRANSP', 'OPAQUE');
-		$vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
-		$vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
-			'CN' => 'pierre@general-store.com',
-			'CUTYPE' => 'INDIVIDUAL',
-			'ROLE' => 'REQ-PARTICIPANT',
-			'PARTSTAT' => 'ACCEPTED',
-		]);
-
-		// construct calendar with a event for reply
-		$this->vCalendar3a = new VCalendar();
-		/** @var VEvent $vEvent */
-		$vEvent = $this->vCalendar3a->add('VEVENT', []);
-		$vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
-		$vEvent->add('DTSTART', '20210820');
-		$vEvent->add('DTEND', '20220821');
-		$vEvent->add('SUMMARY', 'berry basket');
-		$vEvent->add('SEQUENCE', 3);
-		$vEvent->add('STATUS', 'CANCELLED');
-		$vEvent->add('TRANSP', 'OPAQUE');
-		$vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
-		$vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
-			'CN' => 'pierre@general-store.com',
-			'CUTYPE' => 'INDIVIDUAL',
-			'ROLE' => 'REQ-PARTICIPANT',
-			'PARTSTAT' => 'ACCEPTED',
-		]);
-
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
-	public function testSearch($search1, $search2, $expected): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('simple:1');
-		$calendar1->expects($this->once())
-			->method('search')
-			->with('', [], [], null, null)
-			->willReturn($search1);
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('simple:2');
-		$calendar2->expects($this->once())
-			->method('search')
-			->with('', [], [], null, null)
-			->willReturn($search2);
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->search('');
-		$this->assertEquals($expected, $result);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
-	public function testSearchOptions($search1, $search2, $expected): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('simple:1');
-		$calendar1->expects($this->once())
-			->method('search')
-			->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
-				['timerange' => ['start' => null, 'end' => null]], 5, 20)
-			->willReturn($search1);
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('simple:2');
-		$calendar2->expects($this->once())
-			->method('search')
-			->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
-				['timerange' => ['start' => null, 'end' => null]], 5, 20)
-			->willReturn($search2);
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->search('searchTerm', ['SUMMARY', 'DESCRIPTION'],
-			['timerange' => ['start' => null, 'end' => null]], 5, 20);
-		$this->assertEquals($expected, $result);
-	}
-
-	public static function searchProvider(): array {
-		$search1 = [
-			[
-				'id' => 1,
-				'data' => 'foobar',
-			],
-			[
-				'id' => 2,
-				'data' => 'barfoo',
-			]
-		];
-		$search2 = [
-			[
-				'id' => 3,
-				'data' => 'blablub',
-			],
-			[
-				'id' => 4,
-				'data' => 'blubbla',
-			]
-		];
-
-		$expected = [
-			[
-				'id' => 1,
-				'data' => 'foobar',
-				'calendar-key' => 'simple:1',
-			],
-			[
-				'id' => 2,
-				'data' => 'barfoo',
-				'calendar-key' => 'simple:1',
-			],
-			[
-				'id' => 3,
-				'data' => 'blablub',
-				'calendar-key' => 'simple:2',
-			],
-			[
-				'id' => 4,
-				'data' => 'blubbla',
-				'calendar-key' => 'simple:2',
-			]
-		];
-
-		return [
-			[
-				$search1,
-				$search2,
-				$expected
-			]
-		];
-	}
-
-	public function testRegisterUnregister(): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('key1');
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('key2');
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->getCalendars();
-		$this->assertCount(2, $result);
-		$this->assertContains($calendar1, $result);
-		$this->assertContains($calendar2, $result);
-
-		$this->manager->unregisterCalendar($calendar1);
-
-		$result = $this->manager->getCalendars();
-		$this->assertCount(1, $result);
-		$this->assertContains($calendar2, $result);
-	}
-
-	public function testGetCalendars(): void {
-		/** @var ICalendar | MockObject $calendar1 */
-		$calendar1 = $this->createMock(ICalendar::class);
-		$calendar1->method('getKey')->willReturn('key1');
-
-		/** @var ICalendar | MockObject $calendar2 */
-		$calendar2 = $this->createMock(ICalendar::class);
-		$calendar2->method('getKey')->willReturn('key2');
-
-		$this->manager->registerCalendar($calendar1);
-		$this->manager->registerCalendar($calendar2);
-
-		$result = $this->manager->getCalendars();
-		$this->assertCount(2, $result);
-		$this->assertContains($calendar1, $result);
-		$this->assertContains($calendar2, $result);
-
-		$this->manager->clear();
-
-		$result = $this->manager->getCalendars();
-
-		$this->assertCount(0, $result);
-	}
-
-	public function testEnabledIfNot(): void {
-		$isEnabled = $this->manager->isEnabled();
-		$this->assertFalse($isEnabled);
-	}
-
-	public function testIfEnabledIfSo(): void {
-		/** @var ICalendar | MockObject $calendar */
-		$calendar = $this->createMock(ICalendar::class);
-		$this->manager->registerCalendar($calendar);
-
-		$isEnabled = $this->manager->isEnabled();
-		$this->assertTrue($isEnabled);
-	}
-
-	public function testHandleImipRequestWithNoCalendars(): void {
-		// construct calendar manager returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message could not be processed because user has no calendars');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithInvalidData(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('error')
-			->with('iMip message could not be processed because an error occurred while parsing the iMip message');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, 'Invalid data');
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithNoMethod(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains an incorrect or invalid method');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithInvalidMethod(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains an incorrect or invalid method');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'CANCEL');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithNoEvent(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains no event');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		$calendar->remove('VEVENT');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithNoUid(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains a UID');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		$calendar->VEVENT->remove('UID');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithNoOrganizer(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains an organizer');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		$calendar->VEVENT->remove('ORGANIZER');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithNoAttendee(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains any attendees');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		$calendar->VEVENT->remove('ATTENDEE');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithInvalidAttendee(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event does not contain a attendee that matches the recipient');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee2@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequestWithNoMatch(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		$userCalendar->expects(self::once())
-			->method('isDeleted')
-			->willReturn(false);
-		$userCalendar->expects(self::once())
-			->method('isWritable')
-			->willReturn(true);
-		$userCalendar->expects(self::once())
-			->method('isShared')
-			->willReturn(false);
-		$userCalendar->expects(self::once())
-			->method('search')
-			->willReturn([]);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event could not be processed because no corresponding event was found in any calendar');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipRequest(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		$userCalendar->expects(self::once())
-			->method('isDeleted')
-			->willReturn(false);
-		$userCalendar->expects(self::once())
-			->method('isWritable')
-			->willReturn(true);
-		$userCalendar->expects(self::once())
-			->method('isShared')
-			->willReturn(false);
-		$userCalendar->expects(self::once())
-			->method('search')
-			->willReturn([['uri' => 'principals/user/attendee1/personal']]);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$calendar = $this->vCalendar1a;
-		$calendar->add('METHOD', 'REQUEST');
-		// construct user calendar returns
-		$userCalendar->expects(self::once())
-			->method('handleIMipMessage')
-			->with('', $calendar->serialize());
-		// Act
-		$result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertTrue($result);
-	}
-
-	public function testHandleImipReplyWithNoCalendars(): void {
-		// construct calendar manager returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message could not be processed because user has no calendars');
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendar = $this->vCalendar2a;
-		$calendar->add('METHOD', 'REPLY');
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyWithInvalidData(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('error')
-			->with('iMip message could not be processed because an error occurred while parsing the iMip message');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, 'Invalid data');
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyWithNoMethod(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains an incorrect or invalid method');
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendar = $this->vCalendar2a;
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyWithInvalidMethod(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains an incorrect or invalid method');
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendar = $this->vCalendar2a;
-		$calendar->add('METHOD', 'UNKNOWN');
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyWithNoEvent(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains no event');
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendar = $this->vCalendar2a;
-		$calendar->add('METHOD', 'REPLY');
-		$calendar->remove('VEVENT');
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyWithNoUid(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains a UID');
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendar = $this->vCalendar2a;
-		$calendar->add('METHOD', 'REPLY');
-		$calendar->VEVENT->remove('UID');
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyWithNoOrganizer(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains an organizer');
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendar = $this->vCalendar2a;
-		$calendar->add('METHOD', 'REPLY');
-		$calendar->VEVENT->remove('ORGANIZER');
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyWithNoAttendee(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains any attendees');
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendar = $this->vCalendar2a;
-		$calendar->add('METHOD', 'REPLY');
-		$calendar->VEVENT->remove('ATTENDEE');
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyDateInThePast(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger and time returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event could not be processed because the event is in the past');
-		$this->time->expects(self::once())
-			->method('getTime')
-			->willReturn(time());
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendarData = clone $this->vCalendar2a;
-		$calendarData->add('METHOD', 'REPLY');
-		$calendarData->VEVENT->DTSTART = new \DateTime('2013-04-07'); // set to in the past
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReplyEventNotFound(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		$userCalendar->expects(self::once())
-			->method('search')
-			->willReturn([]);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct time returns
-		$this->time->expects(self::once())
-			->method('getTime')
-			->willReturn(1628374233);
-		// construct parameters
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendarData = clone $this->vCalendar2a;
-		$calendarData->add('METHOD', 'REPLY');
-		// construct logger return
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event could not be processed because no corresponding event was found in any calendar', ['principalUri' => $principalUri, 'eventUid' => $calendarData->VEVENT->UID->getValue()]);
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipReply(): void {
-		/** @var Manager | \PHPUnit\Framework\MockObject\MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods([
-				'getCalendarsForPrincipal'
-			])
-			->getMock();
-		$calendar = $this->createMock(ITestCalendar::class);
-		$principalUri = 'principals/user/linus';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$calendarData = clone $this->vCalendar2a;
-		$calendarData->add('METHOD', 'REPLY');
-
-		$this->time->expects(self::once())
-			->method('getTime')
-			->willReturn(1628374233);
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$calendar]);
-		$calendar->expects(self::once())
-			->method('search')
-			->willReturn([['uri' => 'testname.ics']]);
-		$calendar->expects(self::once())
-			->method('handleIMipMessage')
-			->with('testname.ics', $calendarData->serialize());
-		// Act
-		$result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertTrue($result);
-	}
-
-	public function testHandleImipCancelWithNoCalendars(): void {
-		// construct calendar manager returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message could not be processed because user has no calendars');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendar = $this->vCalendar3a;
-		$calendar->add('METHOD', 'CANCEL');
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelWithInvalidData(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('error')
-			->with('iMip message could not be processed because an error occurred while parsing the iMip message');
-		// construct parameters
-		$principalUri = 'principals/user/attendee1';
-		$sender = 'organizer@testing.com';
-		$recipient = 'attendee1@testing.com';
-		$replyTo = null;
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, 'Invalid data');
-		// Assert
-		$this->assertFalse($result);
-	}
-
-
-	public function testHandleImipCancelWithNoMethod(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains an incorrect or invalid method');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendar = $this->vCalendar3a;
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelWithInvalidMethod(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains an incorrect or invalid method');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendar = $this->vCalendar3a;
-		$calendar->add('METHOD', 'UNKNOWN');
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelWithNoEvent(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message contains no event');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendar = $this->vCalendar3a;
-		$calendar->add('METHOD', 'CANCEL');
-		$calendar->remove('VEVENT');
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelWithNoUid(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains a UID');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendar = $this->vCalendar3a;
-		$calendar->add('METHOD', 'CANCEL');
-		$calendar->VEVENT->remove('UID');
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelWithNoOrganizer(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains an organizer');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendar = $this->vCalendar3a;
-		$calendar->add('METHOD', 'CANCEL');
-		$calendar->VEVENT->remove('ORGANIZER');
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelWithNoAttendee(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event dose not contains any attendees');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'pierre@general-store.com';
-		$recipient = 'linus@stardew-tent-living.com';
-		$replyTo = null;
-		$calendar = $this->vCalendar3a;
-		$calendar->add('METHOD', 'CANCEL');
-		$calendar->VEVENT->remove('ATTENDEE');
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelAttendeeNotRecipient(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event could not be processed because recipient must be an ATTENDEE of this event');
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'leah@general-store.com';
-		$replyTo = null;
-		$calendarData = clone $this->vCalendar3a;
-		$calendarData->add('METHOD', 'CANCEL');
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelDateInThePast(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct logger and time returns
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event could not be processed because the event is in the past');
-		$this->time->expects(self::once())
-			->method('getTime')
-			->willReturn(time());
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendarData = clone $this->vCalendar3a;
-		$calendarData->add('METHOD', 'CANCEL');
-		$calendarData->VEVENT->DTSTART = new \DateTime('2013-04-07'); // set to in the past
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelEventNotFound(): void {
-		// construct mock user calendar
-		$userCalendar = $this->createMock(ITestCalendar::class);
-		$userCalendar->expects(self::once())
-			->method('search')
-			->willReturn([]);
-		// construct mock calendar manager and returns
-		/** @var Manager&MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods(['getCalendarsForPrincipal'])
-			->getMock();
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->willReturn([$userCalendar]);
-		// construct time returns
-		$this->time->expects(self::once())
-			->method('getTime')
-			->willReturn(1628374233);
-		// construct parameters
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendarData = clone $this->vCalendar3a;
-		$calendarData->add('METHOD', 'CANCEL');
-		// construct logger return
-		$this->logger->expects(self::once())->method('warning')
-			->with('iMip message event could not be processed because no corresponding event was found in any calendar', ['principalUri' => $principalUri, 'eventUid' => $calendarData->VEVENT->UID->getValue()]);
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertFalse($result);
-	}
-
-	public function testHandleImipCancelOrganiserInReplyTo(): void {
-		/** @var Manager | \PHPUnit\Framework\MockObject\MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods([
-				'getCalendarsForPrincipal'
-			])
-			->getMock();
-
-		$principalUri = 'principals/user/pierre';
-		$sender = 'clint@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = 'linus@stardew-tent-living.com';
-		$calendar = $this->createMock(ITestCalendar::class);
-		$calendarData = clone $this->vCalendar3a;
-		$calendarData->add('METHOD', 'CANCEL');
-
-		$this->time->expects(self::once())
-			->method('getTime')
-			->willReturn(1628374233);
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->with($principalUri)
-			->willReturn([$calendar]);
-		$calendar->expects(self::once())
-			->method('search')
-			->willReturn([['uri' => 'testname.ics']]);
-		$calendar->expects(self::once())
-			->method('handleIMipMessage')
-			->with('testname.ics', $calendarData->serialize());
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertTrue($result);
-	}
-
-	public function testHandleImipCancel(): void {
-		/** @var Manager | \PHPUnit\Framework\MockObject\MockObject $manager */
-		$manager = $this->getMockBuilder(Manager::class)
-			->setConstructorArgs([
-				$this->coordinator,
-				$this->container,
-				$this->logger,
-				$this->time,
-				$this->secureRandom,
-				$this->userManager,
-				$this->serverFactory,
-			])
-			->onlyMethods([
-				'getCalendarsForPrincipal'
-			])
-			->getMock();
-		$principalUri = 'principals/user/pierre';
-		$sender = 'linus@stardew-tent-living.com';
-		$recipient = 'pierre@general-store.com';
-		$replyTo = null;
-		$calendar = $this->createMock(ITestCalendar::class);
-		$calendarData = clone $this->vCalendar3a;
-		$calendarData->add('METHOD', 'CANCEL');
-
-		$this->time->expects(self::once())
-			->method('getTime')
-			->willReturn(1628374233);
-		$manager->expects(self::once())
-			->method('getCalendarsForPrincipal')
-			->with($principalUri)
-			->willReturn([$calendar]);
-		$calendar->expects(self::once())
-			->method('search')
-			->willReturn([['uri' => 'testname.ics']]);
-		$calendar->expects(self::once())
-			->method('handleIMipMessage')
-			->with('testname.ics', $calendarData->serialize());
-		// Act
-		$result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
-		// Assert
-		$this->assertTrue($result);
-	}
-
-	private function getFreeBusyResponse(): string {
-		return <<<EOF
+    /** @var Coordinator&MockObject */
+    private $coordinator;
+
+    /** @var ContainerInterface&MockObject */
+    private $container;
+
+    /** @var LoggerInterface&MockObject */
+    private $logger;
+
+    /** @var Manager */
+    private $manager;
+
+    /** @var ITimeFactory&MockObject */
+    private $time;
+
+    /** @var ISecureRandom&MockObject */
+    private ISecureRandom $secureRandom;
+
+    private IUserManager&MockObject $userManager;
+    private ServerFactory&MockObject $serverFactory;
+
+    private VCalendar $vCalendar1a;
+    private VCalendar $vCalendar2a;
+    private VCalendar $vCalendar3a;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->coordinator = $this->createMock(Coordinator::class);
+        $this->container = $this->createMock(ContainerInterface::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->time = $this->createMock(ITimeFactory::class);
+        $this->secureRandom = $this->createMock(ISecureRandom::class);
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->serverFactory = $this->createMock(ServerFactory::class);
+
+        $this->manager = new Manager(
+            $this->coordinator,
+            $this->container,
+            $this->logger,
+            $this->time,
+            $this->secureRandom,
+            $this->userManager,
+            $this->serverFactory,
+        );
+
+        // construct calendar with a 1 hour event and same start/end time zones
+        $this->vCalendar1a = new VCalendar();
+        /** @var VEvent $vEvent */
+        $vEvent = $this->vCalendar1a->add('VEVENT', []);
+        $vEvent->UID->setValue('96a0e6b1-d886-4a55-a60d-152b31401dcc');
+        $vEvent->add('DTSTART', '20240701T080000', ['TZID' => 'America/Toronto']);
+        $vEvent->add('DTEND', '20240701T090000', ['TZID' => 'America/Toronto']);
+        $vEvent->add('SUMMARY', 'Test Event');
+        $vEvent->add('SEQUENCE', 3);
+        $vEvent->add('STATUS', 'CONFIRMED');
+        $vEvent->add('TRANSP', 'OPAQUE');
+        $vEvent->add('ORGANIZER', 'mailto:organizer@testing.com', ['CN' => 'Organizer']);
+        $vEvent->add('ATTENDEE', 'mailto:attendee1@testing.com', [
+            'CN' => 'Attendee One',
+            'CUTYPE' => 'INDIVIDUAL',
+            'PARTSTAT' => 'NEEDS-ACTION',
+            'ROLE' => 'REQ-PARTICIPANT',
+            'RSVP' => 'TRUE'
+        ]);
+
+        // construct calendar with a event for reply
+        $this->vCalendar2a = new VCalendar();
+        /** @var VEvent $vEvent */
+        $vEvent = $this->vCalendar2a->add('VEVENT', []);
+        $vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
+        $vEvent->add('DTSTART', '20210820');
+        $vEvent->add('DTEND', '20220821');
+        $vEvent->add('SUMMARY', 'berry basket');
+        $vEvent->add('SEQUENCE', 3);
+        $vEvent->add('STATUS', 'CONFIRMED');
+        $vEvent->add('TRANSP', 'OPAQUE');
+        $vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
+        $vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
+            'CN' => 'pierre@general-store.com',
+            'CUTYPE' => 'INDIVIDUAL',
+            'ROLE' => 'REQ-PARTICIPANT',
+            'PARTSTAT' => 'ACCEPTED',
+        ]);
+
+        // construct calendar with a event for reply
+        $this->vCalendar3a = new VCalendar();
+        /** @var VEvent $vEvent */
+        $vEvent = $this->vCalendar3a->add('VEVENT', []);
+        $vEvent->UID->setValue('dcc733bf-b2b2-41f2-a8cf-550ae4b67aff');
+        $vEvent->add('DTSTART', '20210820');
+        $vEvent->add('DTEND', '20220821');
+        $vEvent->add('SUMMARY', 'berry basket');
+        $vEvent->add('SEQUENCE', 3);
+        $vEvent->add('STATUS', 'CANCELLED');
+        $vEvent->add('TRANSP', 'OPAQUE');
+        $vEvent->add('ORGANIZER', 'mailto:linus@stardew-tent-living.com', ['CN' => 'admin']);
+        $vEvent->add('ATTENDEE', 'mailto:pierre@general-store.com', [
+            'CN' => 'pierre@general-store.com',
+            'CUTYPE' => 'INDIVIDUAL',
+            'ROLE' => 'REQ-PARTICIPANT',
+            'PARTSTAT' => 'ACCEPTED',
+        ]);
+
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
+    public function testSearch($search1, $search2, $expected): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('simple:1');
+        $calendar1->expects($this->once())
+            ->method('search')
+            ->with('', [], [], null, null)
+            ->willReturn($search1);
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('simple:2');
+        $calendar2->expects($this->once())
+            ->method('search')
+            ->with('', [], [], null, null)
+            ->willReturn($search2);
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->search('');
+        $this->assertEquals($expected, $result);
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('searchProvider')]
+    public function testSearchOptions($search1, $search2, $expected): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('simple:1');
+        $calendar1->expects($this->once())
+            ->method('search')
+            ->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
+                ['timerange' => ['start' => null, 'end' => null]], 5, 20)
+            ->willReturn($search1);
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('simple:2');
+        $calendar2->expects($this->once())
+            ->method('search')
+            ->with('searchTerm', ['SUMMARY', 'DESCRIPTION'],
+                ['timerange' => ['start' => null, 'end' => null]], 5, 20)
+            ->willReturn($search2);
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->search('searchTerm', ['SUMMARY', 'DESCRIPTION'],
+            ['timerange' => ['start' => null, 'end' => null]], 5, 20);
+        $this->assertEquals($expected, $result);
+    }
+
+    public static function searchProvider(): array {
+        $search1 = [
+            [
+                'id' => 1,
+                'data' => 'foobar',
+            ],
+            [
+                'id' => 2,
+                'data' => 'barfoo',
+            ]
+        ];
+        $search2 = [
+            [
+                'id' => 3,
+                'data' => 'blablub',
+            ],
+            [
+                'id' => 4,
+                'data' => 'blubbla',
+            ]
+        ];
+
+        $expected = [
+            [
+                'id' => 1,
+                'data' => 'foobar',
+                'calendar-key' => 'simple:1',
+            ],
+            [
+                'id' => 2,
+                'data' => 'barfoo',
+                'calendar-key' => 'simple:1',
+            ],
+            [
+                'id' => 3,
+                'data' => 'blablub',
+                'calendar-key' => 'simple:2',
+            ],
+            [
+                'id' => 4,
+                'data' => 'blubbla',
+                'calendar-key' => 'simple:2',
+            ]
+        ];
+
+        return [
+            [
+                $search1,
+                $search2,
+                $expected
+            ]
+        ];
+    }
+
+    public function testRegisterUnregister(): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('key1');
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('key2');
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->getCalendars();
+        $this->assertCount(2, $result);
+        $this->assertContains($calendar1, $result);
+        $this->assertContains($calendar2, $result);
+
+        $this->manager->unregisterCalendar($calendar1);
+
+        $result = $this->manager->getCalendars();
+        $this->assertCount(1, $result);
+        $this->assertContains($calendar2, $result);
+    }
+
+    public function testGetCalendars(): void {
+        /** @var ICalendar | MockObject $calendar1 */
+        $calendar1 = $this->createMock(ICalendar::class);
+        $calendar1->method('getKey')->willReturn('key1');
+
+        /** @var ICalendar | MockObject $calendar2 */
+        $calendar2 = $this->createMock(ICalendar::class);
+        $calendar2->method('getKey')->willReturn('key2');
+
+        $this->manager->registerCalendar($calendar1);
+        $this->manager->registerCalendar($calendar2);
+
+        $result = $this->manager->getCalendars();
+        $this->assertCount(2, $result);
+        $this->assertContains($calendar1, $result);
+        $this->assertContains($calendar2, $result);
+
+        $this->manager->clear();
+
+        $result = $this->manager->getCalendars();
+
+        $this->assertCount(0, $result);
+    }
+
+    public function testEnabledIfNot(): void {
+        $isEnabled = $this->manager->isEnabled();
+        $this->assertFalse($isEnabled);
+    }
+
+    public function testIfEnabledIfSo(): void {
+        /** @var ICalendar | MockObject $calendar */
+        $calendar = $this->createMock(ICalendar::class);
+        $this->manager->registerCalendar($calendar);
+
+        $isEnabled = $this->manager->isEnabled();
+        $this->assertTrue($isEnabled);
+    }
+
+    public function testHandleImipRequestWithNoCalendars(): void {
+        // construct calendar manager returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message could not be processed because user has no calendars');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithInvalidData(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('error')
+            ->with('iMip message could not be processed because an error occurred while parsing the iMip message');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, 'Invalid data');
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithNoMethod(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains an incorrect or invalid method');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithInvalidMethod(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains an incorrect or invalid method');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'CANCEL');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithNoEvent(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains no event');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        $calendar->remove('VEVENT');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithNoUid(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains a UID');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        $calendar->VEVENT->remove('UID');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithNoOrganizer(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains an organizer');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        $calendar->VEVENT->remove('ORGANIZER');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithNoAttendee(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains any attendees');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        $calendar->VEVENT->remove('ATTENDEE');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithInvalidAttendee(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event does not contain a attendee that matches the recipient');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee2@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequestWithNoMatch(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        $userCalendar->expects(self::once())
+            ->method('isDeleted')
+            ->willReturn(false);
+        $userCalendar->expects(self::once())
+            ->method('isWritable')
+            ->willReturn(true);
+        $userCalendar->expects(self::once())
+            ->method('isShared')
+            ->willReturn(false);
+        $userCalendar->expects(self::once())
+            ->method('search')
+            ->willReturn([]);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event could not be processed because no corresponding event was found in any calendar');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipRequest(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        $userCalendar->expects(self::once())
+            ->method('isDeleted')
+            ->willReturn(false);
+        $userCalendar->expects(self::once())
+            ->method('isWritable')
+            ->willReturn(true);
+        $userCalendar->expects(self::once())
+            ->method('isShared')
+            ->willReturn(false);
+        $userCalendar->expects(self::once())
+            ->method('search')
+            ->willReturn([['uri' => 'principals/user/attendee1/personal']]);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $calendar = $this->vCalendar1a;
+        $calendar->add('METHOD', 'REQUEST');
+        // construct user calendar returns
+        $userCalendar->expects(self::once())
+            ->method('handleIMipMessage')
+            ->with('', $calendar->serialize());
+        // Act
+        $result = $manager->handleIMipRequest($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertTrue($result);
+    }
+
+    public function testHandleImipReplyWithNoCalendars(): void {
+        // construct calendar manager returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message could not be processed because user has no calendars');
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendar = $this->vCalendar2a;
+        $calendar->add('METHOD', 'REPLY');
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyWithInvalidData(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('error')
+            ->with('iMip message could not be processed because an error occurred while parsing the iMip message');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, 'Invalid data');
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyWithNoMethod(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains an incorrect or invalid method');
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendar = $this->vCalendar2a;
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyWithInvalidMethod(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains an incorrect or invalid method');
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendar = $this->vCalendar2a;
+        $calendar->add('METHOD', 'UNKNOWN');
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyWithNoEvent(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains no event');
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendar = $this->vCalendar2a;
+        $calendar->add('METHOD', 'REPLY');
+        $calendar->remove('VEVENT');
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyWithNoUid(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains a UID');
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendar = $this->vCalendar2a;
+        $calendar->add('METHOD', 'REPLY');
+        $calendar->VEVENT->remove('UID');
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyWithNoOrganizer(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains an organizer');
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendar = $this->vCalendar2a;
+        $calendar->add('METHOD', 'REPLY');
+        $calendar->VEVENT->remove('ORGANIZER');
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyWithNoAttendee(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains any attendees');
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendar = $this->vCalendar2a;
+        $calendar->add('METHOD', 'REPLY');
+        $calendar->VEVENT->remove('ATTENDEE');
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyDateInThePast(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger and time returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event could not be processed because the event is in the past');
+        $this->time->expects(self::once())
+            ->method('getTime')
+            ->willReturn(time());
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendarData = clone $this->vCalendar2a;
+        $calendarData->add('METHOD', 'REPLY');
+        $calendarData->VEVENT->DTSTART = new \DateTime('2013-04-07'); // set to in the past
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReplyEventNotFound(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        $userCalendar->expects(self::once())
+            ->method('search')
+            ->willReturn([]);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct time returns
+        $this->time->expects(self::once())
+            ->method('getTime')
+            ->willReturn(1628374233);
+        // construct parameters
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendarData = clone $this->vCalendar2a;
+        $calendarData->add('METHOD', 'REPLY');
+        // construct logger return
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event could not be processed because no corresponding event was found in any calendar', ['principalUri' => $principalUri, 'eventUid' => $calendarData->VEVENT->UID->getValue()]);
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipReply(): void {
+        /** @var Manager | \PHPUnit\Framework\MockObject\MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods([
+                'getCalendarsForPrincipal'
+            ])
+            ->getMock();
+        $calendar = $this->createMock(ITestCalendar::class);
+        $principalUri = 'principals/user/linus';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $calendarData = clone $this->vCalendar2a;
+        $calendarData->add('METHOD', 'REPLY');
+
+        $this->time->expects(self::once())
+            ->method('getTime')
+            ->willReturn(1628374233);
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$calendar]);
+        $calendar->expects(self::once())
+            ->method('search')
+            ->willReturn([['uri' => 'testname.ics']]);
+        $calendar->expects(self::once())
+            ->method('handleIMipMessage')
+            ->with('testname.ics', $calendarData->serialize());
+        // Act
+        $result = $manager->handleIMipReply($principalUri, $sender, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertTrue($result);
+    }
+
+    public function testHandleImipCancelWithNoCalendars(): void {
+        // construct calendar manager returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message could not be processed because user has no calendars');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendar = $this->vCalendar3a;
+        $calendar->add('METHOD', 'CANCEL');
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelWithInvalidData(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('error')
+            ->with('iMip message could not be processed because an error occurred while parsing the iMip message');
+        // construct parameters
+        $principalUri = 'principals/user/attendee1';
+        $sender = 'organizer@testing.com';
+        $recipient = 'attendee1@testing.com';
+        $replyTo = null;
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, 'Invalid data');
+        // Assert
+        $this->assertFalse($result);
+    }
+
+
+    public function testHandleImipCancelWithNoMethod(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains an incorrect or invalid method');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendar = $this->vCalendar3a;
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelWithInvalidMethod(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains an incorrect or invalid method');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendar = $this->vCalendar3a;
+        $calendar->add('METHOD', 'UNKNOWN');
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelWithNoEvent(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message contains no event');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendar = $this->vCalendar3a;
+        $calendar->add('METHOD', 'CANCEL');
+        $calendar->remove('VEVENT');
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelWithNoUid(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains a UID');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendar = $this->vCalendar3a;
+        $calendar->add('METHOD', 'CANCEL');
+        $calendar->VEVENT->remove('UID');
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelWithNoOrganizer(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains an organizer');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendar = $this->vCalendar3a;
+        $calendar->add('METHOD', 'CANCEL');
+        $calendar->VEVENT->remove('ORGANIZER');
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelWithNoAttendee(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event dose not contains any attendees');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'pierre@general-store.com';
+        $recipient = 'linus@stardew-tent-living.com';
+        $replyTo = null;
+        $calendar = $this->vCalendar3a;
+        $calendar->add('METHOD', 'CANCEL');
+        $calendar->VEVENT->remove('ATTENDEE');
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendar->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelAttendeeNotRecipient(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event could not be processed because recipient must be an ATTENDEE of this event');
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'leah@general-store.com';
+        $replyTo = null;
+        $calendarData = clone $this->vCalendar3a;
+        $calendarData->add('METHOD', 'CANCEL');
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelDateInThePast(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct logger and time returns
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event could not be processed because the event is in the past');
+        $this->time->expects(self::once())
+            ->method('getTime')
+            ->willReturn(time());
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendarData = clone $this->vCalendar3a;
+        $calendarData->add('METHOD', 'CANCEL');
+        $calendarData->VEVENT->DTSTART = new \DateTime('2013-04-07'); // set to in the past
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelEventNotFound(): void {
+        // construct mock user calendar
+        $userCalendar = $this->createMock(ITestCalendar::class);
+        $userCalendar->expects(self::once())
+            ->method('search')
+            ->willReturn([]);
+        // construct mock calendar manager and returns
+        /** @var Manager&MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods(['getCalendarsForPrincipal'])
+            ->getMock();
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->willReturn([$userCalendar]);
+        // construct time returns
+        $this->time->expects(self::once())
+            ->method('getTime')
+            ->willReturn(1628374233);
+        // construct parameters
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendarData = clone $this->vCalendar3a;
+        $calendarData->add('METHOD', 'CANCEL');
+        // construct logger return
+        $this->logger->expects(self::once())->method('warning')
+            ->with('iMip message event could not be processed because no corresponding event was found in any calendar', ['principalUri' => $principalUri, 'eventUid' => $calendarData->VEVENT->UID->getValue()]);
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertFalse($result);
+    }
+
+    public function testHandleImipCancelOrganiserInReplyTo(): void {
+        /** @var Manager | \PHPUnit\Framework\MockObject\MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods([
+                'getCalendarsForPrincipal'
+            ])
+            ->getMock();
+
+        $principalUri = 'principals/user/pierre';
+        $sender = 'clint@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = 'linus@stardew-tent-living.com';
+        $calendar = $this->createMock(ITestCalendar::class);
+        $calendarData = clone $this->vCalendar3a;
+        $calendarData->add('METHOD', 'CANCEL');
+
+        $this->time->expects(self::once())
+            ->method('getTime')
+            ->willReturn(1628374233);
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->with($principalUri)
+            ->willReturn([$calendar]);
+        $calendar->expects(self::once())
+            ->method('search')
+            ->willReturn([['uri' => 'testname.ics']]);
+        $calendar->expects(self::once())
+            ->method('handleIMipMessage')
+            ->with('testname.ics', $calendarData->serialize());
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertTrue($result);
+    }
+
+    public function testHandleImipCancel(): void {
+        /** @var Manager | \PHPUnit\Framework\MockObject\MockObject $manager */
+        $manager = $this->getMockBuilder(Manager::class)
+            ->setConstructorArgs([
+                $this->coordinator,
+                $this->container,
+                $this->logger,
+                $this->time,
+                $this->secureRandom,
+                $this->userManager,
+                $this->serverFactory,
+            ])
+            ->onlyMethods([
+                'getCalendarsForPrincipal'
+            ])
+            ->getMock();
+        $principalUri = 'principals/user/pierre';
+        $sender = 'linus@stardew-tent-living.com';
+        $recipient = 'pierre@general-store.com';
+        $replyTo = null;
+        $calendar = $this->createMock(ITestCalendar::class);
+        $calendarData = clone $this->vCalendar3a;
+        $calendarData->add('METHOD', 'CANCEL');
+
+        $this->time->expects(self::once())
+            ->method('getTime')
+            ->willReturn(1628374233);
+        $manager->expects(self::once())
+            ->method('getCalendarsForPrincipal')
+            ->with($principalUri)
+            ->willReturn([$calendar]);
+        $calendar->expects(self::once())
+            ->method('search')
+            ->willReturn([['uri' => 'testname.ics']]);
+        $calendar->expects(self::once())
+            ->method('handleIMipMessage')
+            ->with('testname.ics', $calendarData->serialize());
+        // Act
+        $result = $manager->handleIMipCancel($principalUri, $sender, $replyTo, $recipient, $calendarData->serialize());
+        // Assert
+        $this->assertTrue($result);
+    }
+
+    private function getFreeBusyResponse(): string {
+        return <<<EOF
 <?xml version="1.0" encoding="utf-8"?>
 <cal:schedule-response xmlns:d="DAV:" xmlns:s="http://sabredav.org/ns" xmlns:cal="urn:ietf:params:xml:ns:caldav" xmlns:cs="http://calendarserver.org/ns/" xmlns:oc="http://owncloud.org/ns" xmlns:nc="http://nextcloud.org/ns">
   <cal:response>
@@ -1696,139 +1696,139 @@ 
   </cal:response>
 </cal:schedule-response>
 EOF;
-	}
-
-	public function testCheckAvailability(): void {
-		$organizer = $this->createMock(IUser::class);
-		$organizer->expects(self::once())
-			->method('getUID')
-			->willReturn('admin');
-		$organizer->expects(self::once())
-			->method('getEMailAddress')
-			->willReturn('admin@imap.localhost');
-
-		$user1 = $this->createMock(IUser::class);
-		$user2 = $this->createMock(IUser::class);
-
-		$this->userManager->expects(self::exactly(3))
-			->method('getByEmail')
-			->willReturnMap([
-				['user@imap.localhost', [$user1]],
-				['empty@imap.localhost', [$user2]],
-				['nouser@domain.tld', []],
-			]);
-
-		$authPlugin = $this->createMock(CustomPrincipalPlugin::class);
-		$authPlugin->expects(self::once())
-			->method('setCurrentPrincipal')
-			->with('principals/users/admin');
-
-		$server = $this->createMock(Server::class);
-		$server->expects(self::once())
-			->method('getPlugin')
-			->with('auth')
-			->willReturn($authPlugin);
-		$server->expects(self::once())
-			->method('invokeMethod')
-			->willReturnCallback(function (
-				RequestInterface $request,
-				ResponseInterface $response,
-				bool $sendResponse,
-			): void {
-				$requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
-				$this->assertEquals('POST', $request->getMethod());
-				$this->assertEquals('calendars/admin/outbox', $request->getPath());
-				$this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
-				$this->assertEquals('0', $request->getHeader('Depth'));
-				$this->assertEquals($requestBody, $request->getBodyAsString());
-				$this->assertFalse($sendResponse);
-				$response->setStatus(200);
-				$response->setBody($this->getFreeBusyResponse());
-			});
-
-		$this->serverFactory->expects(self::once())
-			->method('createAttendeeAvailabilityServer')
-			->willReturn($server);
-
-		$start = new DateTimeImmutable('2025-01-16T06:00:00Z');
-		$end = new DateTimeImmutable('2025-01-17T06:00:00Z');
-		$actual = $this->manager->checkAvailability($start, $end, $organizer, [
-			'user@imap.localhost',
-			'empty@imap.localhost',
-			'nouser@domain.tld',
-		]);
-		$expected = [
-			new AvailabilityResult('admin@imap.localhost', false),
-			new AvailabilityResult('empty@imap.localhost', true),
-			new AvailabilityResult('user@imap.localhost', false),
-		];
-		$this->assertEquals($expected, $actual);
-	}
-
-	public function testCheckAvailabilityWithMailtoPrefix(): void {
-		$organizer = $this->createMock(IUser::class);
-		$organizer->expects(self::once())
-			->method('getUID')
-			->willReturn('admin');
-		$organizer->expects(self::once())
-			->method('getEMailAddress')
-			->willReturn('admin@imap.localhost');
-
-		$user1 = $this->createMock(IUser::class);
-		$user2 = $this->createMock(IUser::class);
-
-		$this->userManager->expects(self::exactly(3))
-			->method('getByEmail')
-			->willReturnMap([
-				['user@imap.localhost', [$user1]],
-				['empty@imap.localhost', [$user2]],
-				['nouser@domain.tld', []],
-			]);
-
-		$authPlugin = $this->createMock(CustomPrincipalPlugin::class);
-		$authPlugin->expects(self::once())
-			->method('setCurrentPrincipal')
-			->with('principals/users/admin');
-
-		$server = $this->createMock(Server::class);
-		$server->expects(self::once())
-			->method('getPlugin')
-			->with('auth')
-			->willReturn($authPlugin);
-		$server->expects(self::once())
-			->method('invokeMethod')
-			->willReturnCallback(function (
-				RequestInterface $request,
-				ResponseInterface $response,
-				bool $sendResponse,
-			): void {
-				$requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
-				$this->assertEquals('POST', $request->getMethod());
-				$this->assertEquals('calendars/admin/outbox', $request->getPath());
-				$this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
-				$this->assertEquals('0', $request->getHeader('Depth'));
-				$this->assertEquals($requestBody, $request->getBodyAsString());
-				$this->assertFalse($sendResponse);
-				$response->setStatus(200);
-				$response->setBody($this->getFreeBusyResponse());
-			});
-
-		$this->serverFactory->expects(self::once())
-			->method('createAttendeeAvailabilityServer')
-			->willReturn($server);
-
-		$start = new DateTimeImmutable('2025-01-16T06:00:00Z');
-		$end = new DateTimeImmutable('2025-01-17T06:00:00Z');
-		$actual = $this->manager->checkAvailability($start, $end, $organizer, [
-			'mailto:user@imap.localhost',
-			'mailto:empty@imap.localhost',
-			'mailto:nouser@domain.tld',
-		]);
-		$expected = [
-			new AvailabilityResult('admin@imap.localhost', false),
-			new AvailabilityResult('empty@imap.localhost', true),
-			new AvailabilityResult('user@imap.localhost', false),
-		];
-		$this->assertEquals($expected, $actual);
-	}
+    }
+
+    public function testCheckAvailability(): void {
+        $organizer = $this->createMock(IUser::class);
+        $organizer->expects(self::once())
+            ->method('getUID')
+            ->willReturn('admin');
+        $organizer->expects(self::once())
+            ->method('getEMailAddress')
+            ->willReturn('admin@imap.localhost');
+
+        $user1 = $this->createMock(IUser::class);
+        $user2 = $this->createMock(IUser::class);
+
+        $this->userManager->expects(self::exactly(3))
+            ->method('getByEmail')
+            ->willReturnMap([
+                ['user@imap.localhost', [$user1]],
+                ['empty@imap.localhost', [$user2]],
+                ['nouser@domain.tld', []],
+            ]);
+
+        $authPlugin = $this->createMock(CustomPrincipalPlugin::class);
+        $authPlugin->expects(self::once())
+            ->method('setCurrentPrincipal')
+            ->with('principals/users/admin');
+
+        $server = $this->createMock(Server::class);
+        $server->expects(self::once())
+            ->method('getPlugin')
+            ->with('auth')
+            ->willReturn($authPlugin);
+        $server->expects(self::once())
+            ->method('invokeMethod')
+            ->willReturnCallback(function (
+                RequestInterface $request,
+                ResponseInterface $response,
+                bool $sendResponse,
+            ): void {
+                $requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
+                $this->assertEquals('POST', $request->getMethod());
+                $this->assertEquals('calendars/admin/outbox', $request->getPath());
+                $this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
+                $this->assertEquals('0', $request->getHeader('Depth'));
+                $this->assertEquals($requestBody, $request->getBodyAsString());
+                $this->assertFalse($sendResponse);
+                $response->setStatus(200);
+                $response->setBody($this->getFreeBusyResponse());
+            });
+
+        $this->serverFactory->expects(self::once())
+            ->method('createAttendeeAvailabilityServer')
+            ->willReturn($server);
+
+        $start = new DateTimeImmutable('2025-01-16T06:00:00Z');
+        $end = new DateTimeImmutable('2025-01-17T06:00:00Z');
+        $actual = $this->manager->checkAvailability($start, $end, $organizer, [
+            'user@imap.localhost',
+            'empty@imap.localhost',
+            'nouser@domain.tld',
+        ]);
+        $expected = [
+            new AvailabilityResult('admin@imap.localhost', false),
+            new AvailabilityResult('empty@imap.localhost', true),
+            new AvailabilityResult('user@imap.localhost', false),
+        ];
+        $this->assertEquals($expected, $actual);
+    }
+
+    public function testCheckAvailabilityWithMailtoPrefix(): void {
+        $organizer = $this->createMock(IUser::class);
+        $organizer->expects(self::once())
+            ->method('getUID')
+            ->willReturn('admin');
+        $organizer->expects(self::once())
+            ->method('getEMailAddress')
+            ->willReturn('admin@imap.localhost');
+
+        $user1 = $this->createMock(IUser::class);
+        $user2 = $this->createMock(IUser::class);
+
+        $this->userManager->expects(self::exactly(3))
+            ->method('getByEmail')
+            ->willReturnMap([
+                ['user@imap.localhost', [$user1]],
+                ['empty@imap.localhost', [$user2]],
+                ['nouser@domain.tld', []],
+            ]);
+
+        $authPlugin = $this->createMock(CustomPrincipalPlugin::class);
+        $authPlugin->expects(self::once())
+            ->method('setCurrentPrincipal')
+            ->with('principals/users/admin');
+
+        $server = $this->createMock(Server::class);
+        $server->expects(self::once())
+            ->method('getPlugin')
+            ->with('auth')
+            ->willReturn($authPlugin);
+        $server->expects(self::once())
+            ->method('invokeMethod')
+            ->willReturnCallback(function (
+                RequestInterface $request,
+                ResponseInterface $response,
+                bool $sendResponse,
+            ): void {
+                $requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
+                $this->assertEquals('POST', $request->getMethod());
+                $this->assertEquals('calendars/admin/outbox', $request->getPath());
+                $this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
+                $this->assertEquals('0', $request->getHeader('Depth'));
+                $this->assertEquals($requestBody, $request->getBodyAsString());
+                $this->assertFalse($sendResponse);
+                $response->setStatus(200);
+                $response->setBody($this->getFreeBusyResponse());
+            });
+
+        $this->serverFactory->expects(self::once())
+            ->method('createAttendeeAvailabilityServer')
+            ->willReturn($server);
+
+        $start = new DateTimeImmutable('2025-01-16T06:00:00Z');
+        $end = new DateTimeImmutable('2025-01-17T06:00:00Z');
+        $actual = $this->manager->checkAvailability($start, $end, $organizer, [
+            'mailto:user@imap.localhost',
+            'mailto:empty@imap.localhost',
+            'mailto:nouser@domain.tld',
+        ]);
+        $expected = [
+            new AvailabilityResult('admin@imap.localhost', false),
+            new AvailabilityResult('empty@imap.localhost', true),
+            new AvailabilityResult('user@imap.localhost', false),
+        ];
+        $this->assertEquals($expected, $actual);
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -1730,12 +1730,12 @@ 
 			->willReturn($authPlugin);
 		$server->expects(self::once())
 			->method('invokeMethod')
-			->willReturnCallback(function (
+			->willReturnCallback(function(
 				RequestInterface $request,
 				ResponseInterface $response,
 				bool $sendResponse,
 			): void {
-				$requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
+				$requestBody = file_get_contents(__DIR__.'/../../data/ics/free-busy-request.ics');
 				$this->assertEquals('POST', $request->getMethod());
 				$this->assertEquals('calendars/admin/outbox', $request->getPath());
 				$this->assertEquals('text/calendar', $request->getHeader('Content-Type'));
@@ -1797,12 +1797,12 @@ 
 			->willReturn($authPlugin);
 		$server->expects(self::once())
 			->method('invokeMethod')
-			->willReturnCallback(function (
+			->willReturnCallback(function(
 				RequestInterface $request,
 				ResponseInterface $response,
 				bool $sendResponse,
 			): void {
-				$requestBody = file_get_contents(__DIR__ . '/../../data/ics/free-busy-request.ics');
+				$requestBody = file_get_contents(__DIR__.'/../../data/ics/free-busy-request.ics');
 				$this->assertEquals('POST', $request->getMethod());
 				$this->assertEquals('calendars/admin/outbox', $request->getPath());
 				$this->assertEquals('text/calendar', $request->getHeader('Content-Type'));