Sabre\CalDAV\Backend\AbstractPDOTest Class Reference

Inheritance diagram for Sabre\CalDAV\Backend\AbstractPDOTest:

Collaboration diagram for Sabre\CalDAV\Backend\AbstractPDOTest:

Public Member Functions
	setUp ()
	testConstruct ()
	testGetCalendarsForUserNoCalendars ()
	@depends testConstruct More...
	testCreateCalendarAndFetch ()
	@depends testConstruct More...
	testUpdateCalendarAndFetch ()
	@depends testConstruct More...
	testUpdateCalendarBadId ()
	@depends testConstruct @expectedException \InvalidArgumentException More...
	testUpdateCalendarUnknownProperty ()
	@depends testUpdateCalendarAndFetch More...
	testDeleteCalendar ()
	@depends testCreateCalendarAndFetch More...
	testDeleteCalendarBadID ()
	@depends testCreateCalendarAndFetch @expectedException \InvalidArgumentException More...
	testCreateCalendarIncorrectComponentSet ()
	@depends testCreateCalendarAndFetch @expectedException \Sabre\DAV\Exception More...
	testCreateCalendarObject ()
	testGetMultipleObjects ()
	testGetMultipleObjectsBadId ()
	@depends testGetMultipleObjects @expectedException \InvalidArgumentException More...
	testCreateCalendarObjectNoComponent ()
	@expectedException Sabre\DAV\Exception\BadRequest @depends testCreateCalendarObject More...
	testCreateCalendarObjectDuration ()
	@depends testCreateCalendarObject More...
	testCreateCalendarObjectBadId ()
	@depends testCreateCalendarObject @expectedException \InvalidArgumentException More...
	testCreateCalendarObjectNoDTEND ()
	@depends testCreateCalendarObject More...
	testCreateCalendarObjectWithDTEND ()
	@depends testCreateCalendarObject More...
	testCreateCalendarObjectInfiniteRecurrence ()
	@depends testCreateCalendarObject More...
	testCreateCalendarObjectEndingRecurrence ()
	@depends testCreateCalendarObject More...
	testCreateCalendarObjectTask ()
	@depends testCreateCalendarObject More...
	testGetCalendarObjects ()
	@depends testCreateCalendarObject More...
	testGetCalendarObjectsBadId ()
	@depends testGetCalendarObjects @expectedException \InvalidArgumentException More...
	testGetCalendarObjectBadId ()
	@depends testGetCalendarObjects @expectedException \InvalidArgumentException More...
	testGetCalendarObjectByUID ()
	@depends testCreateCalendarObject More...
	testUpdateCalendarObject ()
	@depends testCreateCalendarObject More...
	testUpdateCalendarObjectBadId ()
	@depends testUpdateCalendarObject @expectedException \InvalidArgumentException More...
	testDeleteCalendarObject ()
	@depends testCreateCalendarObject More...
	testDeleteCalendarObjectBadId ()
	@depends testDeleteCalendarObject @expectedException \InvalidArgumentException More...
	testCalendarQueryNoResult ()
	testCalendarQueryBadId ()
	@expectedException \InvalidArgumentException @depends testCalendarQueryNoResult More...
	testCalendarQueryTodo ()
	testCalendarQueryTodoNotMatch ()
	testCalendarQueryNoFilter ()
	testCalendarQueryTimeRange ()
	testCalendarQueryTimeRangeNoEnd ()
	testGetChanges ()
	testGetChangesBadId ()
	@depends testGetChanges @expectedException \InvalidArgumentException More...
	testCreateSubscriptions ()
	testCreateSubscriptionFail ()
	@expectedException \Sabre\DAV\Exception\Forbidden More...
	testUpdateSubscriptions ()
	testUpdateSubscriptionsFail ()
	testDeleteSubscriptions ()
	testSchedulingMethods ()
	testGetInvites ()
	testGetInvitesBadId ()
	@depends testGetInvites @expectedException \InvalidArgumentException More...
	testUpdateInvites ()
	@depends testCreateCalendarAndFetch More...
	testUpdateInvitesBadId ()
	@depends testUpdateInvites @expectedException \InvalidArgumentException More...
	testUpdateInvitesNoPrincipal ()
	@depends testUpdateInvites More...
	testDeleteSharedCalendar ()
	@depends testUpdateInvites More...
	testSetPublishStatus ()
	@expectedException \Sabre\DAV\Exception\NotImplemented More...

Protected Attributes
	$pdo

Detailed Description

Definition at line 10 of file AbstractPDOTest.php.

Member Function Documentation

setUp()

Sabre\CalDAV\Backend\AbstractPDOTest::setUp

(

)

Definition at line 16 of file AbstractPDOTest.php.

                     {
 
        $this->dropTables([
            'calendarobjects',
            'calendars',
            'calendarinstances',
            'calendarchanges',
            'calendarsubscriptions',
            'schedulingobjects',
        ]);
        $this->createSchema('calendars');
 
        $this->pdo = $this->getDb();
 
    }

References Sabre\DAV\createSchema(), Sabre\DAV\dropTables(), and Sabre\DAV\getDb().

Here is the call graph for this function:

testCalendarQueryBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testCalendarQueryBadId

(

)

@expectedException \InvalidArgumentException @depends testCalendarQueryNoResult

Definition at line 688 of file AbstractPDOTest.php.

                                      {
 
        $abstract = new PDO($this->pdo);
        $filters = [
            'name'         => 'VCALENDAR',
            'comp-filters' => [
                [
                    'name'           => 'VJOURNAL',
                    'comp-filters'   => [],
                    'prop-filters'   => [],
                    'is-not-defined' => false,
                    'time-range'     => null,
                ],
            ],
            'prop-filters'   => [],
            'is-not-defined' => false,
            'time-range'     => null,
        ];
 
        $abstract->calendarQuery('bad-id', $filters);
 
    }

testCalendarQueryNoFilter()

Sabre\CalDAV\Backend\AbstractPDOTest::testCalendarQueryNoFilter

(

)

Definition at line 773 of file AbstractPDOTest.php.

                                         {
 
        $backend = new PDO($this->pdo);
        $backend->createCalendarObject([1, 1], "todo", "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nEND:VTODO\r\nEND:VCALENDAR\r\n");
        $backend->createCalendarObject([1, 1], "event", "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n");
 
        $filters = [
            'name'           => 'VCALENDAR',
            'comp-filters'   => [],
            'prop-filters'   => [],
            'is-not-defined' => false,
            'time-range'     => null,
        ];
 
        $result = $backend->calendarQuery([1, 1], $filters);
        $this->assertTrue(in_array('todo', $result));
        $this->assertTrue(in_array('event', $result));
 
    }

References $result.

testCalendarQueryNoResult()

Sabre\CalDAV\Backend\AbstractPDOTest::testCalendarQueryNoResult

(

)

Definition at line 660 of file AbstractPDOTest.php.

                                         {
 
        $abstract = new PDO($this->pdo);
        $filters = [
            'name'         => 'VCALENDAR',
            'comp-filters' => [
                [
                    'name'           => 'VJOURNAL',
                    'comp-filters'   => [],
                    'prop-filters'   => [],
                    'is-not-defined' => false,
                    'time-range'     => null,
                ],
            ],
            'prop-filters'   => [],
            'is-not-defined' => false,
            'time-range'     => null,
        ];
 
        $this->assertEquals([
        ], $abstract->calendarQuery([1, 1], $filters));
 
    }

testCalendarQueryTimeRange()

Sabre\CalDAV\Backend\AbstractPDOTest::testCalendarQueryTimeRange

(

)

Definition at line 793 of file AbstractPDOTest.php.

                                          {
 
        $backend = new PDO($this->pdo);
        $backend->createCalendarObject([1, 1], "todo", "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nEND:VTODO\r\nEND:VCALENDAR\r\n");
        $backend->createCalendarObject([1, 1], "event", "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n");
        $backend->createCalendarObject([1, 1], "event2", "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120103\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n");
 
        $filters = [
            'name'         => 'VCALENDAR',
            'comp-filters' => [
                [
                    'name'           => 'VEVENT',
                    'comp-filters'   => [],
                    'prop-filters'   => [],
                    'is-not-defined' => false,
                    'time-range'     => [
                        'start' => new \DateTime('20120103'),
                        'end'   => new \DateTime('20120104'),
                    ],
                ],
            ],
            'prop-filters'   => [],
            'is-not-defined' => false,
            'time-range'     => null,
        ];
 
        $this->assertEquals([
            "event2",
        ], $backend->calendarQuery([1, 1], $filters));
 
    }

testCalendarQueryTimeRangeNoEnd()

Sabre\CalDAV\Backend\AbstractPDOTest::testCalendarQueryTimeRangeNoEnd

(

)

Definition at line 824 of file AbstractPDOTest.php.

                                               {
 
        $backend = new PDO($this->pdo);
        $backend->createCalendarObject([1, 1], "todo", "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nEND:VTODO\r\nEND:VCALENDAR\r\n");
        $backend->createCalendarObject([1, 1], "event", "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n");
        $backend->createCalendarObject([1, 1], "event2", "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART:20120103\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n");
 
        $filters = [
            'name'         => 'VCALENDAR',
            'comp-filters' => [
                [
                    'name'           => 'VEVENT',
                    'comp-filters'   => [],
                    'prop-filters'   => [],
                    'is-not-defined' => false,
                    'time-range'     => [
                        'start' => new \DateTime('20120102'),
                        'end'   => null,
                    ],
                ],
            ],
            'prop-filters'   => [],
            'is-not-defined' => false,
            'time-range'     => null,
        ];
 
        $this->assertEquals([
            "event2",
        ], $backend->calendarQuery([1, 1], $filters));
 
    }

testCalendarQueryTodo()

Sabre\CalDAV\Backend\AbstractPDOTest::testCalendarQueryTodo

(

)

Definition at line 711 of file AbstractPDOTest.php.

                                     {
 
        $backend = new PDO($this->pdo);
        $backend->createCalendarObject([1, 1], "todo", "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nEND:VTODO\r\nEND:VCALENDAR\r\n");
        $backend->createCalendarObject([1, 1], "event", "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n");
 
        $filters = [
            'name'         => 'VCALENDAR',
            'comp-filters' => [
                [
                    'name'           => 'VTODO',
                    'comp-filters'   => [],
                    'prop-filters'   => [],
                    'is-not-defined' => false,
                    'time-range'     => null,
                ],
            ],
            'prop-filters'   => [],
            'is-not-defined' => false,
            'time-range'     => null,
        ];
 
        $this->assertEquals([
            "todo",
        ], $backend->calendarQuery([1, 1], $filters));
 
    }

testCalendarQueryTodoNotMatch()

Sabre\CalDAV\Backend\AbstractPDOTest::testCalendarQueryTodoNotMatch

(

)

Definition at line 738 of file AbstractPDOTest.php.

                                             {
 
        $backend = new PDO($this->pdo);
        $backend->createCalendarObject([1, 1], "todo", "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nEND:VTODO\r\nEND:VCALENDAR\r\n");
        $backend->createCalendarObject([1, 1], "event", "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n");
 
        $filters = [
            'name'         => 'VCALENDAR',
            'comp-filters' => [
                [
                    'name'         => 'VTODO',
                    'comp-filters' => [],
                    'prop-filters' => [
                        [
                            'name'           => 'summary',
                            'text-match'     => null,
                            'time-range'     => null,
                            'param-filters'  => [],
                            'is-not-defined' => false,
                        ],
                    ],
                    'is-not-defined' => false,
                    'time-range'     => null,
                ],
            ],
            'prop-filters'   => [],
            'is-not-defined' => false,
            'time-range'     => null,
        ];
 
        $this->assertEquals([
        ], $backend->calendarQuery([1, 1], $filters));
 
    }

testConstruct()

Sabre\CalDAV\Backend\AbstractPDOTest::testConstruct

(

)

Definition at line 32 of file AbstractPDOTest.php.

                             {
 
        $backend = new PDO($this->pdo);
        $this->assertTrue($backend instanceof PDO);
 
    }

testCreateCalendarAndFetch()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarAndFetch

(

)

@depends testConstruct

Definition at line 53 of file AbstractPDOTest.php.

                                          {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', [
            '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set' => new CalDAV\Xml\Property\SupportedCalendarComponentSet(['VEVENT']),
            '{DAV:}displayname'                                               => 'Hello!',
            '{urn:ietf:params:xml:ns:caldav}schedule-calendar-transp'         => new CalDAV\Xml\Property\ScheduleCalendarTransp('transparent'),
        ]);
        $calendars = $backend->getCalendarsForUser('principals/user2');
 
        $elementCheck = [
            'uri'                                                     => 'somerandomid',
            '{DAV:}displayname'                                       => 'Hello!',
            '{urn:ietf:params:xml:ns:caldav}calendar-description'     => '',
            '{urn:ietf:params:xml:ns:caldav}schedule-calendar-transp' => new CalDAV\Xml\Property\ScheduleCalendarTransp('transparent'),
            'share-access'                                            => \Sabre\DAV\Sharing\Plugin::ACCESS_SHAREDOWNER,
        ];
 
        $this->assertInternalType('array', $calendars);
        $this->assertEquals(1, count($calendars));
 
        foreach ($elementCheck as $name => $value) {
 
            $this->assertArrayHasKey($name, $calendars[0]);
            $this->assertEquals($value, $calendars[0][$name]);
 
        }
 
    }

References $name, and Sabre\DAV\Sharing\Plugin\ACCESS_SHAREDOWNER.

testCreateCalendarIncorrectComponentSet()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarIncorrectComponentSet

(

)

@depends testCreateCalendarAndFetch @expectedException \Sabre\DAV\Exception

Definition at line 217 of file AbstractPDOTest.php.

                                                       {;
 
        $backend = new PDO($this->pdo);
 
        //Creating a new calendar
        $newId = $backend->createCalendar('principals/user2', 'somerandomid', [
            '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set' => 'blabla',
        ]);
 
    }

testCreateCalendarObject()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObject

(

)

Definition at line 228 of file AbstractPDOTest.php.

                                        {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $result = $this->pdo->query('SELECT etag, size, calendardata, firstoccurence, lastoccurence, componenttype FROM calendarobjects WHERE uri = \'random-id\'');
 
        $row = $result->fetch(\PDO::FETCH_ASSOC);
        if (is_resource($row['calendardata'])) {
            $row['calendardata'] = stream_get_contents($row['calendardata']);
        }
 
        $this->assertEquals([
            'etag'           => md5($object),
            'size'           => strlen($object),
            'calendardata'   => $object,
            'firstoccurence' => strtotime('20120101'),
            'lastoccurence'  => strtotime('20120101') + (3600 * 24),
            'componenttype'  => 'VEVENT',
        ], $row);
 
    }

References $result, and $row.

testCreateCalendarObjectBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectBadId

(

)

@depends testCreateCalendarObject @expectedException \InvalidArgumentException

Definition at line 371 of file AbstractPDOTest.php.

                                             {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nDURATION:P2D\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject('bad-id', 'random-id', $object);
 
    }

testCreateCalendarObjectDuration()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectDuration

(

)

@depends testCreateCalendarObject

Definition at line 340 of file AbstractPDOTest.php.

                                                {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nDURATION:P2D\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $result = $this->pdo->query('SELECT etag, size, calendardata, firstoccurence, lastoccurence, componenttype FROM calendarobjects WHERE uri = \'random-id\'');
 
        $row = $result->fetch(\PDO::FETCH_ASSOC);
        if (is_resource($row['calendardata'])) {
            $row['calendardata'] = stream_get_contents($row['calendardata']);
        }
 
        $this->assertEquals([
            'etag'           => md5($object),
            'size'           => strlen($object),
            'calendardata'   => $object,
            'firstoccurence' => strtotime('20120101'),
            'lastoccurence'  => strtotime('20120101') + (3600 * 48),
            'componenttype'  => 'VEVENT',
        ], $row);
 
    }

References $result, and $row.

testCreateCalendarObjectEndingRecurrence()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectEndingRecurrence

(

)

@depends testCreateCalendarObject

Definition at line 473 of file AbstractPDOTest.php.

                                                        {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE-TIME:20120101T100000Z\r\nDTEND;VALUE=DATE-TIME:20120101T110000Z\r\nUID:foo\r\nRRULE:FREQ=DAILY;COUNT=1000\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $result = $this->pdo->query('SELECT etag, size, calendardata, firstoccurence, lastoccurence, componenttype FROM calendarobjects WHERE uri = \'random-id\'');
        $row = $result->fetch(\PDO::FETCH_ASSOC);
        if (is_resource($row['calendardata'])) {
            $row['calendardata'] = stream_get_contents($row['calendardata']);
        }
 
        $this->assertEquals([
            'etag'           => md5($object),
            'size'           => strlen($object),
            'calendardata'   => $object,
            'firstoccurence' => strtotime('2012-01-01 10:00:00'),
            'lastoccurence'  => strtotime('2012-01-01 11:00:00') + (3600 * 24 * 999),
            'componenttype'  => 'VEVENT',
        ], $row);
 
    }

References $result, and $row.

testCreateCalendarObjectInfiniteRecurrence()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectInfiniteRecurrence

(

)

@depends testCreateCalendarObject

Definition at line 444 of file AbstractPDOTest.php.

                                                          {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE-TIME:20120101T100000Z\r\nRRULE:FREQ=DAILY\r\nUID:foo\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $result = $this->pdo->query('SELECT etag, size, calendardata, firstoccurence, lastoccurence, componenttype FROM calendarobjects WHERE uri = \'random-id\'');
        $row = $result->fetch(\PDO::FETCH_ASSOC);
        if (is_resource($row['calendardata'])) {
            $row['calendardata'] = stream_get_contents($row['calendardata']);
        }
 
        $this->assertEquals([
            'etag'           => md5($object),
            'size'           => strlen($object),
            'calendardata'   => $object,
            'firstoccurence' => strtotime('2012-01-01 10:00:00'),
            'lastoccurence'  => strtotime(PDO::MAX_DATE),
            'componenttype'  => 'VEVENT',
        ], $row);
 
    }

References $result, $row, and Sabre\CalDAV\Backend\PDO\MAX_DATE.

testCreateCalendarObjectNoComponent()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectNoComponent

(

)

@expectedException Sabre\DAV\Exception\BadRequest @depends testCreateCalendarObject

Definition at line 326 of file AbstractPDOTest.php.

                                                   {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VTIMEZONE\r\nEND:VTIMEZONE\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
    }

testCreateCalendarObjectNoDTEND()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectNoDTEND

(

)

@depends testCreateCalendarObject

Definition at line 386 of file AbstractPDOTest.php.

                                               {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE-TIME:20120101T100000Z\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $result = $this->pdo->query('SELECT etag, size, calendardata, firstoccurence, lastoccurence, componenttype FROM calendarobjects WHERE uri = \'random-id\'');
        $row = $result->fetch(\PDO::FETCH_ASSOC);
        if (is_resource($row['calendardata'])) {
            $row['calendardata'] = stream_get_contents($row['calendardata']);
        }
 
        $this->assertEquals([
            'etag'           => md5($object),
            'size'           => strlen($object),
            'calendardata'   => $object,
            'firstoccurence' => strtotime('2012-01-01 10:00:00'),
            'lastoccurence'  => strtotime('2012-01-01 10:00:00'),
            'componenttype'  => 'VEVENT',
        ], $row);
 
    }

References $result, and $row.

testCreateCalendarObjectTask()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectTask

(

)

@depends testCreateCalendarObject

Definition at line 502 of file AbstractPDOTest.php.

                                            {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nDUE;VALUE=DATE-TIME:20120101T100000Z\r\nEND:VTODO\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $result = $this->pdo->query('SELECT etag, size, calendardata, firstoccurence, lastoccurence, componenttype FROM calendarobjects WHERE uri = \'random-id\'');
        $row = $result->fetch(\PDO::FETCH_ASSOC);
        if (is_resource($row['calendardata'])) {
            $row['calendardata'] = stream_get_contents($row['calendardata']);
        }
 
        $this->assertEquals([
            'etag'           => md5($object),
            'size'           => strlen($object),
            'calendardata'   => $object,
            'firstoccurence' => null,
            'lastoccurence'  => null,
            'componenttype'  => 'VTODO',
        ], $row);
 
    }

References $result, and $row.

testCreateCalendarObjectWithDTEND()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateCalendarObjectWithDTEND

(

)

@depends testCreateCalendarObject

Definition at line 415 of file AbstractPDOTest.php.

                                                 {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE-TIME:20120101T100000Z\r\nDTEND:20120101T110000Z\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $result = $this->pdo->query('SELECT etag, size, calendardata, firstoccurence, lastoccurence, componenttype FROM calendarobjects WHERE uri = \'random-id\'');
        $row = $result->fetch(\PDO::FETCH_ASSOC);
        if (is_resource($row['calendardata'])) {
            $row['calendardata'] = stream_get_contents($row['calendardata']);
        }
 
        $this->assertEquals([
            'etag'           => md5($object),
            'size'           => strlen($object),
            'calendardata'   => $object,
            'firstoccurence' => strtotime('2012-01-01 10:00:00'),
            'lastoccurence'  => strtotime('2012-01-01 11:00:00'),
            'componenttype'  => 'VEVENT',
        ], $row);
 
    }

References $result, and $row.

testCreateSubscriptionFail()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateSubscriptionFail

(

)

@expectedException \Sabre\DAV\Exception\Forbidden

Definition at line 953 of file AbstractPDOTest.php.

                                          {
 
        $props = [
        ];
 
        $backend = new PDO($this->pdo);
        $backend->createSubscription('principals/user1', 'sub1', $props);
 
    }

testCreateSubscriptions()

Sabre\CalDAV\Backend\AbstractPDOTest::testCreateSubscriptions

(

)

Definition at line 918 of file AbstractPDOTest.php.

                                       {
 
        $props = [
            '{http://calendarserver.org/ns/}source'                 => new \Sabre\DAV\Xml\Property\Href('http://example.org/cal.ics', false),
            '{DAV:}displayname'                                     => 'cal',
            '{http://apple.com/ns/ical/}refreshrate'                => 'P1W',
            '{http://apple.com/ns/ical/}calendar-color'             => '#FF00FFFF',
            '{http://calendarserver.org/ns/}subscribed-strip-todos' => true,
            //'{http://calendarserver.org/ns/}subscribed-strip-alarms' => true,
            '{http://calendarserver.org/ns/}subscribed-strip-attachments' => true,
        ];
 
        $backend = new PDO($this->pdo);
        $backend->createSubscription('principals/user1', 'sub1', $props);
 
        $subs = $backend->getSubscriptionsForUser('principals/user1');
 
        $expected = $props;
        $expected['id'] = 1;
        $expected['uri'] = 'sub1';
        $expected['principaluri'] = 'principals/user1';
 
        unset($expected['{http://calendarserver.org/ns/}source']);
        $expected['source'] = 'http://example.org/cal.ics';
 
        $this->assertEquals(1, count($subs));
        foreach ($expected as $k => $v) {
            $this->assertEquals($subs[0][$k], $expected[$k]);
        }
 
    }

testDeleteCalendar()

Sabre\CalDAV\Backend\AbstractPDOTest::testDeleteCalendar

(

)

@depends testCreateCalendarAndFetch

Definition at line 182 of file AbstractPDOTest.php.

                                  {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', [
            '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set' => new CalDAV\Xml\Property\SupportedCalendarComponentSet(['VEVENT']),
            '{DAV:}displayname'                                               => 'Hello!',
        ]);
 
        $backend->deleteCalendar($returnedId);
 
        $calendars = $backend->getCalendarsForUser('principals/user2');
        $this->assertEquals([], $calendars);
 
    }

testDeleteCalendarBadID()

Sabre\CalDAV\Backend\AbstractPDOTest::testDeleteCalendarBadID

(

)

@depends testCreateCalendarAndFetch @expectedException \InvalidArgumentException

Definition at line 201 of file AbstractPDOTest.php.

                                       {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', [
            '{urn:ietf:params:xml:ns:caldav}supported-calendar-component-set' => new CalDAV\Xml\Property\SupportedCalendarComponentSet(['VEVENT']),
            '{DAV:}displayname'                                               => 'Hello!',
        ]);
 
        $backend->deleteCalendar('bad-id');
 
    }

testDeleteCalendarObject()

Sabre\CalDAV\Backend\AbstractPDOTest::testDeleteCalendarObject

(

)

@depends testCreateCalendarObject

Definition at line 631 of file AbstractPDOTest.php.

                                        {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
        $backend->createCalendarObject($returnedId, 'random-id', $object);
        $backend->deleteCalendarObject($returnedId, 'random-id');
 
        $data = $backend->getCalendarObject($returnedId, 'random-id');
        $this->assertNull($data);
 
    }

References $data.

testDeleteCalendarObjectBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testDeleteCalendarObjectBadId

(

)

@depends testDeleteCalendarObject @expectedException \InvalidArgumentException

Definition at line 649 of file AbstractPDOTest.php.

                                             {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
        $backend->createCalendarObject($returnedId, 'random-id', $object);
        $backend->deleteCalendarObject('bad-id', 'random-id');
 
    }

testDeleteSharedCalendar()

Sabre\CalDAV\Backend\AbstractPDOTest::testDeleteSharedCalendar

(

)

@depends testUpdateInvites

Definition at line 1352 of file AbstractPDOTest.php.

                                        {
 
        $backend = new PDO($this->pdo);
 
        // creating a new calendar
        $backend->createCalendar('principals/user1', 'somerandomid', []);
        $calendar = $backend->getCalendarsForUser('principals/user1')[0];
 
        $ownerSharee = new Sharee([
            'href'         => 'principals/user1',
            'principal'    => 'principals/user1',
            'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_SHAREDOWNER,
            'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
        ]);
 
        // Add a new invite
        $backend->updateInvites(
            $calendar['id'],
            [
                new Sharee([
                    'href'         => 'mailto:user@example.org',
                    'principal'    => 'principals/user2',
                    'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_READ,
                    'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
                    'properties'   => ['{DAV:}displayname' => 'User 2'],
                ])
            ]
        );
 
        $expectedCalendar = [
            'id'                                     => [1,2],
            'principaluri'                           => 'principals/user2',
            '{http://calendarserver.org/ns/}getctag' => 'http://sabre.io/ns/sync/1',
            '{http://sabredav.org/ns}sync-token'     => '1',
            'share-access'                           => \Sabre\DAV\Sharing\Plugin::ACCESS_READ,
            'read-only'                              => true,
            'share-resource-uri'                     => '/ns/share/1',
        ];
        $calendars = $backend->getCalendarsForUser('principals/user2');
 
        foreach ($expectedCalendar as $k => $v) {
            $this->assertEquals(
                $v,
                $calendars[0][$k],
                "Key " . $k . " in calendars array did not have the expected value."
            );
        }
 
        // Removing the shared calendar.
        $backend->deleteCalendar($calendars[0]['id']);
 
        $this->assertEquals(
            [],
            $backend->getCalendarsForUser('principals/user2')
        );
 
        $result = $backend->getInvites($calendar['id']);
        $expected = [
            new Sharee([
                'href'         => 'principals/user1',
                'principal'    => 'principals/user1',
                'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_SHAREDOWNER,
                'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
            ]),
        ];
        $this->assertEquals($expected, $result);
 
    }

References $calendar, $result, and Sabre\DAV\Sharing\Plugin\ACCESS_READ.

testDeleteSubscriptions()

Sabre\CalDAV\Backend\AbstractPDOTest::testDeleteSubscriptions

(

)

Definition at line 1038 of file AbstractPDOTest.php.

                                       {
 
        $props = [
            '{http://calendarserver.org/ns/}source'                 => new \Sabre\DAV\Xml\Property\Href('http://example.org/cal.ics', false),
            '{DAV:}displayname'                                     => 'cal',
            '{http://apple.com/ns/ical/}refreshrate'                => 'P1W',
            '{http://apple.com/ns/ical/}calendar-color'             => '#FF00FFFF',
            '{http://calendarserver.org/ns/}subscribed-strip-todos' => true,
            //'{http://calendarserver.org/ns/}subscribed-strip-alarms' => true,
            '{http://calendarserver.org/ns/}subscribed-strip-attachments' => true,
        ];
 
        $backend = new PDO($this->pdo);
        $backend->createSubscription('principals/user1', 'sub1', $props);
 
        $newProps = [
            '{DAV:}displayname'                     => 'new displayname',
            '{http://calendarserver.org/ns/}source' => new \Sabre\DAV\Xml\Property\Href('http://example.org/cal2.ics', false),
        ];
 
        $backend->deleteSubscription(1);
 
        $subs = $backend->getSubscriptionsForUser('principals/user1');
        $this->assertEquals(0, count($subs));
    }

testGetCalendarObjectBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetCalendarObjectBadId

(

)

@depends testGetCalendarObjects @expectedException \InvalidArgumentException

Definition at line 564 of file AbstractPDOTest.php.

                                          {
 
        $backend = new PDO($this->pdo);
        $backend->getCalendarObject('bad-id', 'foo-bar');
 
    }

testGetCalendarObjectByUID()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetCalendarObjectByUID

(

)

@depends testCreateCalendarObject

Definition at line 574 of file AbstractPDOTest.php.

                                          {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nUID:foo\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $this->assertNull(
            $backend->getCalendarObjectByUID('principals/user2', 'bar')
        );
        $this->assertEquals(
            'somerandomid/random-id',
            $backend->getCalendarObjectByUID('principals/user2', 'foo')
        );
 
    }

testGetCalendarObjects()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetCalendarObjects

(

)

@depends testCreateCalendarObject

Definition at line 531 of file AbstractPDOTest.php.

                                      {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
        $backend->createCalendarObject($returnedId, 'random-id', $object);
 
        $data = $backend->getCalendarObjects($returnedId);
 
        $this->assertEquals(1, count($data));
        $data = $data[0];
 
        $this->assertEquals('random-id', $data['uri']);
        $this->assertEquals(strlen($object), $data['size']);
 
    }

References $data.

testGetCalendarObjectsBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetCalendarObjectsBadId

(

)

@depends testGetCalendarObjects @expectedException \InvalidArgumentException

Definition at line 553 of file AbstractPDOTest.php.

                                           {
 
        $backend = new PDO($this->pdo);
        $backend->getCalendarObjects('bad-id');
 
    }

testGetCalendarsForUserNoCalendars()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetCalendarsForUserNoCalendars

(

)

@depends testConstruct

Definition at line 42 of file AbstractPDOTest.php.

                                                  {
 
        $backend = new PDO($this->pdo);
        $calendars = $backend->getCalendarsForUser('principals/user2');
        $this->assertEquals([], $calendars);
 
    }

testGetChanges()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetChanges

(

)

Definition at line 856 of file AbstractPDOTest.php.

                              {
 
        $backend = new PDO($this->pdo);
        $id = $backend->createCalendar(
            'principals/user1',
            'bla',
            []
        );
        $result = $backend->getChangesForCalendar($id, null, 1);
 
        $this->assertEquals([
            'syncToken' => 1,
            'modified'  => [],
            'deleted'   => [],
            'added'     => [],
        ], $result);
 
        $currentToken = $result['syncToken'];
 
        $dummyTodo = "BEGIN:VCALENDAR\r\nBEGIN:VTODO\r\nEND:VTODO\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($id, "todo1.ics", $dummyTodo);
        $backend->createCalendarObject($id, "todo2.ics", $dummyTodo);
        $backend->createCalendarObject($id, "todo3.ics", $dummyTodo);
        $backend->updateCalendarObject($id, "todo1.ics", $dummyTodo);
        $backend->deleteCalendarObject($id, "todo2.ics");
 
        $result = $backend->getChangesForCalendar($id, $currentToken, 1);
 
        $this->assertEquals([
            'syncToken' => 6,
            'modified'  => ["todo1.ics"],
            'deleted'   => ["todo2.ics"],
            'added'     => ["todo3.ics"],
        ], $result);
 
        $result = $backend->getChangesForCalendar($id, null, 1);
 
        $this->assertEquals([
            'syncToken' => 6,
            'modified'  => [],
            'deleted'   => [],
            'added'     => ["todo1.ics", "todo3.ics"],
        ], $result);
    }

References $id, and $result.

testGetChangesBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetChangesBadId

(

)

@depends testGetChanges @expectedException \InvalidArgumentException

Definition at line 906 of file AbstractPDOTest.php.

                                   {
 
        $backend = new PDO($this->pdo);
        $id = $backend->createCalendar(
            'principals/user1',
            'bla',
            []
        );
        $backend->getChangesForCalendar('bad-id', null, 1);
 
    }

References $id.

testGetInvites()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetInvites

(

)

Definition at line 1110 of file AbstractPDOTest.php.

                              {
 
        $backend = new PDO($this->pdo);
 
        // creating a new calendar
        $backend->createCalendar('principals/user1', 'somerandomid', []);
        $calendar = $backend->getCalendarsForUser('principals/user1')[0];
 
        $result = $backend->getInvites($calendar['id']);
        $expected = [
            new Sharee([
                'href'         => 'principals/user1',
                'principal'    => 'principals/user1',
                'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_SHAREDOWNER,
                'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
            ])
        ];
 
        $this->assertEquals($expected, $result);
 
    }

References $calendar, and $result.

testGetInvitesBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetInvitesBadId

(

)

@depends testGetInvites @expectedException \InvalidArgumentException

Definition at line 1136 of file AbstractPDOTest.php.

                                   {
 
        $backend = new PDO($this->pdo);
 
        // creating a new calendar
        $backend->createCalendar('principals/user1', 'somerandomid', []);
        $calendar = $backend->getCalendarsForUser('principals/user1')[0];
 
        $backend->getInvites('bad-id');
 
    }

References $calendar.

testGetMultipleObjects()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetMultipleObjects

(

)

Definition at line 254 of file AbstractPDOTest.php.

                                      {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
 
        $backend->createCalendarObject($returnedId, 'id-1', $object);
        $backend->createCalendarObject($returnedId, 'id-2', $object);
 
        $check = [
            [
                'id'           => 1,
                'etag'         => '"' . md5($object) . '"',
                'uri'          => 'id-1',
                'size'         => strlen($object),
                'calendardata' => $object,
                'lastmodified' => null,
            ],
            [
                'id'           => 2,
                'etag'         => '"' . md5($object) . '"',
                'uri'          => 'id-2',
                'size'         => strlen($object),
                'calendardata' => $object,
                'lastmodified' => null,
            ],
        ];
 
        $result = $backend->getMultipleCalendarObjects($returnedId, ['id-1', 'id-2']);
 
        foreach ($check as $index => $props) {
 
            foreach ($props as $key => $expected) {
 
                $actual = $result[$index][$key];
 
                switch ($key) {
                    case 'lastmodified' :
                        $this->assertInternalType('int', $actual);
                        break;
                    case 'calendardata' :
                        if (is_resource($actual)) {
                            $actual = stream_get_contents($actual);
                        }
                        // no break intentional
                    default :
                        $this->assertEquals($expected, $actual);
 
                }
 
            }
 
        }
 
    }

References $index, $key, and $result.

testGetMultipleObjectsBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testGetMultipleObjectsBadId

(

)

@depends testGetMultipleObjects @expectedException \InvalidArgumentException

Definition at line 315 of file AbstractPDOTest.php.

                                           {
 
        $backend = new PDO($this->pdo);
        $backend->getMultipleCalendarObjects('bad-id', ['foo-bar']);
 
    }

testSchedulingMethods()

Sabre\CalDAV\Backend\AbstractPDOTest::testSchedulingMethods

(

)

Definition at line 1064 of file AbstractPDOTest.php.

                                     {
 
        $backend = new PDO($this->pdo);
 
        $calData = "BEGIN:VCALENDAR\r\nEND:VCALENDAR\r\n";
 
        $backend->createSchedulingObject(
            'principals/user1',
            'schedule1.ics',
            $calData
        );
 
        $expected = [
            'calendardata' => $calData,
            'uri'          => 'schedule1.ics',
            'etag'         => '"' . md5($calData) . '"',
            'size'         => strlen($calData)
        ];
 
        $result = $backend->getSchedulingObject('principals/user1', 'schedule1.ics');
        foreach ($expected as $k => $v) {
            $this->assertArrayHasKey($k, $result);
            if (is_resource($result[$k])) {
                $result[$k] = stream_get_contents($result[$k]);
            }
            $this->assertEquals($v, $result[$k]);
        }
 
        $results = $backend->getSchedulingObjects('principals/user1');
 
        $this->assertEquals(1, count($results));
        $result = $results[0];
        foreach ($expected as $k => $v) {
            if (is_resource($result[$k])) {
                $result[$k] = stream_get_contents($result[$k]);
            }
            $this->assertEquals($v, $result[$k]);
        }
 
        $backend->deleteSchedulingObject('principals/user1', 'schedule1.ics');
        $result = $backend->getSchedulingObject('principals/user1', 'schedule1.ics');
 
        $this->assertNull($result);
 
    }

References $result, and $results.

testSetPublishStatus()

Sabre\CalDAV\Backend\AbstractPDOTest::testSetPublishStatus

(

)

@expectedException \Sabre\DAV\Exception\NotImplemented

Definition at line 1424 of file AbstractPDOTest.php.

                                    {
 
        $backend = new PDO($this->pdo);
        $backend->setPublishStatus([1, 1], true);
 
    }

testUpdateCalendarAndFetch()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateCalendarAndFetch

(

)

@depends testConstruct

Definition at line 86 of file AbstractPDOTest.php.

                                          {
 
        $backend = new PDO($this->pdo);
 
        //Creating a new calendar
        $newId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $propPatch = new PropPatch([
            '{DAV:}displayname'                                       => 'myCalendar',
            '{urn:ietf:params:xml:ns:caldav}schedule-calendar-transp' => new CalDAV\Xml\Property\ScheduleCalendarTransp('transparent'),
        ]);
 
        // Updating the calendar
        $backend->updateCalendar($newId, $propPatch);
        $result = $propPatch->commit();
 
        // Verifying the result of the update
        $this->assertTrue($result);
 
        // Fetching all calendars from this user
        $calendars = $backend->getCalendarsForUser('principals/user2');
 
        // Checking if all the information is still correct
        $elementCheck = [
            'id'                                                      => $newId,
            'uri'                                                     => 'somerandomid',
            '{DAV:}displayname'                                       => 'myCalendar',
            '{urn:ietf:params:xml:ns:caldav}calendar-description'     => '',
            '{urn:ietf:params:xml:ns:caldav}calendar-timezone'        => '',
            '{http://calendarserver.org/ns/}getctag'                  => 'http://sabre.io/ns/sync/2',
            '{urn:ietf:params:xml:ns:caldav}schedule-calendar-transp' => new CalDAV\Xml\Property\ScheduleCalendarTransp('transparent'),
        ];
 
        $this->assertInternalType('array', $calendars);
        $this->assertEquals(1, count($calendars));
 
        foreach ($elementCheck as $name => $value) {
 
            $this->assertArrayHasKey($name, $calendars[0]);
            $this->assertEquals($value, $calendars[0][$name]);
 
        }
 
    }

References $name, and $result.

testUpdateCalendarBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateCalendarBadId

(

)

@depends testConstruct @expectedException \InvalidArgumentException

Definition at line 135 of file AbstractPDOTest.php.

                                       {
 
        $backend = new PDO($this->pdo);
 
        //Creating a new calendar
        $newId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $propPatch = new PropPatch([
            '{DAV:}displayname'                                       => 'myCalendar',
            '{urn:ietf:params:xml:ns:caldav}schedule-calendar-transp' => new CalDAV\Xml\Property\ScheduleCalendarTransp('transparent'),
        ]);
 
        // Updating the calendar
        $backend->updateCalendar('raaaa', $propPatch);
 
    }

testUpdateCalendarObject()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateCalendarObject

(

)

@depends testCreateCalendarObject

Definition at line 595 of file AbstractPDOTest.php.

                                        {
 
        $backend = new PDO($this->pdo);
        $returnedId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $object = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20120101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
        $object2 = "BEGIN:VCALENDAR\r\nBEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20130101\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
        $backend->createCalendarObject($returnedId, 'random-id', $object);
        $backend->updateCalendarObject($returnedId, 'random-id', $object2);
 
        $data = $backend->getCalendarObject($returnedId, 'random-id');
 
        if (is_resource($data['calendardata'])) {
            $data['calendardata'] = stream_get_contents($data['calendardata']);
        }
 
        $this->assertEquals($object2, $data['calendardata']);
        $this->assertEquals('random-id', $data['uri']);
 
 
    }

References $data.

testUpdateCalendarObjectBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateCalendarObjectBadId

(

)

@depends testUpdateCalendarObject @expectedException \InvalidArgumentException

Definition at line 621 of file AbstractPDOTest.php.

                                             {
 
        $backend = new PDO($this->pdo);
        $backend->updateCalendarObject('bad-id', 'object-id', 'objectdata');
 
    }

testUpdateCalendarUnknownProperty()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateCalendarUnknownProperty

(

)

@depends testUpdateCalendarAndFetch

Definition at line 155 of file AbstractPDOTest.php.

                                                 {
 
        $backend = new PDO($this->pdo);
 
        //Creating a new calendar
        $newId = $backend->createCalendar('principals/user2', 'somerandomid', []);
 
        $propPatch = new PropPatch([
            '{DAV:}displayname' => 'myCalendar',
            '{DAV:}yourmom'     => 'wittycomment',
        ]);
 
        // Updating the calendar
        $backend->updateCalendar($newId, $propPatch);
        $propPatch->commit();
 
        // Verifying the result of the update
        $this->assertEquals([
            '{DAV:}yourmom'     => 403,
            '{DAV:}displayname' => 424,
        ], $propPatch->getResult());
 
    }

testUpdateInvites()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateInvites

(

)

@depends testCreateCalendarAndFetch

Definition at line 1151 of file AbstractPDOTest.php.

                                 {
 
        $backend = new PDO($this->pdo);
 
        // creating a new calendar
        $backend->createCalendar('principals/user1', 'somerandomid', []);
        $calendar = $backend->getCalendarsForUser('principals/user1')[0];
 
        $ownerSharee = new Sharee([
            'href'         => 'principals/user1',
            'principal'    => 'principals/user1',
            'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_SHAREDOWNER,
            'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
        ]);
 
        // Add a new invite
        $backend->updateInvites(
            $calendar['id'],
            [
                new Sharee([
                    'href'         => 'mailto:user@example.org',
                    'principal'    => 'principals/user2',
                    'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_READ,
                    'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
                    'properties'   => ['{DAV:}displayname' => 'User 2'],
                ])
            ]
        );
 
        $result = $backend->getInvites($calendar['id']);
        $expected = [
            $ownerSharee,
            new Sharee([
                'href'         => 'mailto:user@example.org',
                'principal'    => 'principals/user2',
                'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_READ,
                'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
                'properties'   => [
                    '{DAV:}displayname' => 'User 2',
                ],
            ])
        ];
        $this->assertEquals($expected, $result);
 
        // Checking calendar_instances too
        $expectedCalendar = [
            'id'                                     => [1,2],
            'principaluri'                           => 'principals/user2',
            '{http://calendarserver.org/ns/}getctag' => 'http://sabre.io/ns/sync/1',
            '{http://sabredav.org/ns}sync-token'     => '1',
            'share-access'                           => \Sabre\DAV\Sharing\Plugin::ACCESS_READ,
            'read-only'                              => true,
            'share-resource-uri'                     => '/ns/share/1',
        ];
        $calendars = $backend->getCalendarsForUser('principals/user2');
 
        foreach ($expectedCalendar as $k => $v) {
            $this->assertEquals(
                $v,
                $calendars[0][$k],
                "Key " . $k . " in calendars array did not have the expected value."
            );
        }
 
 
        // Updating an invite
        $backend->updateInvites(
            $calendar['id'],
            [
                new Sharee([
                    'href'         => 'mailto:user@example.org',
                    'principal'    => 'principals/user2',
                    'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_READWRITE,
                    'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
                ])
            ]
        );
 
        $result = $backend->getInvites($calendar['id']);
        $expected = [
            $ownerSharee,
            new Sharee([
                'href'         => 'mailto:user@example.org',
                'principal'    => 'principals/user2',
                'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_READWRITE,
                'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
                'properties'   => [
                    '{DAV:}displayname' => 'User 2',
                ],
            ])
        ];
        $this->assertEquals($expected, $result);
 
        // Removing an invite
        $backend->updateInvites(
            $calendar['id'],
            [
                new Sharee([
                    'href'   => 'mailto:user@example.org',
                    'access' => \Sabre\DAV\Sharing\Plugin::ACCESS_NOACCESS,
                ])
            ]
        );
 
        $result = $backend->getInvites($calendar['id']);
        $expected = [
            $ownerSharee
        ];
        $this->assertEquals($expected, $result);
 
        // Preventing the owner share from being removed
        $backend->updateInvites(
            $calendar['id'],
            [
                new Sharee([
                    'href'   => 'principals/user2',
                    'access' => \Sabre\DAV\Sharing\Plugin::ACCESS_NOACCESS,
                ])
            ]
        );
 
        $result = $backend->getInvites($calendar['id']);
        $expected = [
            new Sharee([
                'href'         => 'principals/user1',
                'principal'    => 'principals/user1',
                'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_SHAREDOWNER,
                'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
            ]),
        ];
        $this->assertEquals($expected, $result);
 
    }

References $calendar, $result, and Sabre\DAV\Sharing\Plugin\ACCESS_READ.

testUpdateInvitesBadId()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateInvitesBadId

(

)

@depends testUpdateInvites @expectedException \InvalidArgumentException

Definition at line 1289 of file AbstractPDOTest.php.

                                      {
 
        $backend = new PDO($this->pdo);
        // Add a new invite
        $backend->updateInvites(
            'bad-id',
            []
        );
 
    }

testUpdateInvitesNoPrincipal()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateInvitesNoPrincipal

(

)

@depends testUpdateInvites

Definition at line 1303 of file AbstractPDOTest.php.

                                            {
 
        $backend = new PDO($this->pdo);
 
        // creating a new calendar
        $backend->createCalendar('principals/user1', 'somerandomid', []);
        $calendar = $backend->getCalendarsForUser('principals/user1')[0];
 
        $ownerSharee = new Sharee([
            'href'         => 'principals/user1',
            'principal'    => 'principals/user1',
            'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_SHAREDOWNER,
            'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
        ]);
 
        // Add a new invite
        $backend->updateInvites(
            $calendar['id'],
            [
                new Sharee([
                    'href'         => 'mailto:user@example.org',
                    'principal'    => null,
                    'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_READ,
                    'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_ACCEPTED,
                    'properties'   => ['{DAV:}displayname' => 'User 2'],
                ])
            ]
        );
 
        $result = $backend->getInvites($calendar['id']);
        $expected = [
            $ownerSharee,
            new Sharee([
                'href'         => 'mailto:user@example.org',
                'principal'    => null,
                'access'       => \Sabre\DAV\Sharing\Plugin::ACCESS_READ,
                'inviteStatus' => \Sabre\DAV\Sharing\Plugin::INVITE_INVALID,
                'properties'   => [
                    '{DAV:}displayname' => 'User 2',
                ],
            ])
        ];
        $this->assertEquals($expected, $result, null, 0.0, 10, true); // Last argument is $canonicalize = true, which allows us to compare, ignoring the order, because it's different between MySQL and Sqlite.
 
    }

References $calendar, and $result.

testUpdateSubscriptions()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateSubscriptions

(

)

Definition at line 963 of file AbstractPDOTest.php.

                                       {
 
        $props = [
            '{http://calendarserver.org/ns/}source'                 => new \Sabre\DAV\Xml\Property\Href('http://example.org/cal.ics', false),
            '{DAV:}displayname'                                     => 'cal',
            '{http://apple.com/ns/ical/}refreshrate'                => 'P1W',
            '{http://apple.com/ns/ical/}calendar-color'             => '#FF00FFFF',
            '{http://calendarserver.org/ns/}subscribed-strip-todos' => true,
            //'{http://calendarserver.org/ns/}subscribed-strip-alarms' => true,
            '{http://calendarserver.org/ns/}subscribed-strip-attachments' => true,
        ];
 
        $backend = new PDO($this->pdo);
        $backend->createSubscription('principals/user1', 'sub1', $props);
 
        $newProps = [
            '{DAV:}displayname'                     => 'new displayname',
            '{http://calendarserver.org/ns/}source' => new \Sabre\DAV\Xml\Property\Href('http://example.org/cal2.ics', false),
        ];
 
        $propPatch = new DAV\PropPatch($newProps);
        $backend->updateSubscription(1, $propPatch);
        $result = $propPatch->commit();
 
        $this->assertTrue($result);
 
        $subs = $backend->getSubscriptionsForUser('principals/user1');
 
        $expected = array_merge($props, $newProps);
        $expected['id'] = 1;
        $expected['uri'] = 'sub1';
        $expected['principaluri'] = 'principals/user1';
 
        unset($expected['{http://calendarserver.org/ns/}source']);
        $expected['source'] = 'http://example.org/cal2.ics';
 
        $this->assertEquals(1, count($subs));
        foreach ($expected as $k => $v) {
            $this->assertEquals($subs[0][$k], $expected[$k]);
        }
 
    }

References $result.

testUpdateSubscriptionsFail()

Sabre\CalDAV\Backend\AbstractPDOTest::testUpdateSubscriptionsFail

(

)

Definition at line 1006 of file AbstractPDOTest.php.

                                           {
 
        $props = [
            '{http://calendarserver.org/ns/}source'                 => new \Sabre\DAV\Xml\Property\Href('http://example.org/cal.ics', false),
            '{DAV:}displayname'                                     => 'cal',
            '{http://apple.com/ns/ical/}refreshrate'                => 'P1W',
            '{http://apple.com/ns/ical/}calendar-color'             => '#FF00FFFF',
            '{http://calendarserver.org/ns/}subscribed-strip-todos' => true,
            //'{http://calendarserver.org/ns/}subscribed-strip-alarms' => true,
            '{http://calendarserver.org/ns/}subscribed-strip-attachments' => true,
        ];
 
        $backend = new PDO($this->pdo);
        $backend->createSubscription('principals/user1', 'sub1', $props);
 
        $propPatch = new DAV\PropPatch([
            '{DAV:}displayname'                     => 'new displayname',
            '{http://calendarserver.org/ns/}source' => new \Sabre\DAV\Xml\Property\Href('http://example.org/cal2.ics', false),
            '{DAV:}unknown'                         => 'foo',
        ]);
 
        $backend->updateSubscription(1, $propPatch);
        $propPatch->commit();
 
        $this->assertEquals([
            '{DAV:}unknown'                         => 403,
            '{DAV:}displayname'                     => 424,
            '{http://calendarserver.org/ns/}source' => 424,
        ], $propPatch->getResult());
 
    }

Field Documentation

$pdo

Sabre\CalDAV\Backend\AbstractPDOTest::$pdo

protected

Definition at line 14 of file AbstractPDOTest.php.

---

The documentation for this class was generated from the following file:

• libs/composer/vendor/sabre/dav/tests/Sabre/CalDAV/Backend/AbstractPDOTest.php