Differential D14 Diff 26 akonadi/calendar/tests/itiphandlertest.cpp

Changeset View

Standalone View

akonadi/calendar/tests/itiphandlertest.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines	void ITIPHandlerTest::initTestCase()

connect(m_changer, SIGNAL(deleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)),		connect(m_changer, SIGNAL(deleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)),
SLOT(onDeleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)));		SLOT(onDeleteFinished(int,QVector<Akonadi::Item::Id>,Akonadi::IncidenceChanger::ResultCode,QString)));

connect(m_changer,SIGNAL(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),		connect(m_changer,SIGNAL(modifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)),
SLOT(onModifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)));		SLOT(onModifyFinished(int,Akonadi::Item,Akonadi::IncidenceChanger::ResultCode,QString)));
}		}

		void ITIPHandlerTest::testProcessITIPMessageUpdate_data()
		{
		QTest::addColumn<QString>("data_filename");
		QTest::addColumn<QString>("action");
		QTest::addColumn<QString>("receiver");
		QTest::addColumn<QString>("incidenceUid"); // uid of incidence in invitation
		QTest::addColumn<Akonadi::ITIPHandler::Result>("expectedResult");
		QTest::addColumn<int>("expectedNumIncidences");
		QTest::addColumn<KCalCore::Attendee::PartStat>("expectedPartStat");

		QString data_filename;
		QString action = QLatin1String("accepted");
		QString incidenceUid = QString::fromLatin1("uosj936i6arrtl9c2i5r2mfuvg");
		QString receiver = QLatin1String(s_ourEmail);
		Akonadi::ITIPHandler::Result expectedResult;
		int expectedNumIncidences = 0;
		KCalCore::Attendee::PartStat expectedPartStat;

		//----------------------------------------------------------------------------------------------
		// Someone invited us to an event, and we accept
		expectedResult = ITIPHandler::ResultSuccess;
		data_filename = QLatin1String("invited_us");
		expectedNumIncidences = 1;
		expectedPartStat = KCalCore::Attendee::Accepted;
		action = QLatin1String("accepted");
		QTest::newRow("invited us1") << data_filename << action << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		// Someone invited us to an event, and we accept conditionally
		expectedResult = ITIPHandler::ResultSuccess;
		data_filename = QLatin1String("invited_us");
		expectedNumIncidences = 1;
		expectedPartStat = KCalCore::Attendee::Tentative;
		action = QLatin1String("tentative");
		QTest::newRow("invited us2") << data_filename << action << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		// Someone invited us to an event, we delegate it
		expectedResult = ITIPHandler::ResultSuccess;
		data_filename = QLatin1String("invited_us");

		// The e-mail to the delegate is sent by kmail's text_calendar.cpp
		expectedNumIncidences = 1;
		expectedPartStat = KCalCore::Attendee::Delegated;
		action = QLatin1String("delegated");
		QTest::newRow("invited us3") << data_filename << action << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		// Process a CANCEL without having the incidence in our calendar.
		// itiphandler should return success and not error
		expectedResult = ITIPHandler::ResultSuccess;
		data_filename = QLatin1String("invited_us");
		expectedNumIncidences = 0;
		action = QLatin1String("cancel");
		QTest::newRow("invited us4") << data_filename << action << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		// Process a REQUEST without having the incidence in our calendar.
		// itiphandler should return success and add the rquest to a calendar
		expectedResult = ITIPHandler::ResultSuccess;
		data_filename = QLatin1String("invited_us");
		expectedNumIncidences = 1;
		expectedPartStat = KCalCore::Attendee::NeedsAction;
		action = QLatin1String("request");
		QTest::newRow("invited us5") << data_filename << action << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		// Here we're testing an error case, where data is null.
		expectedResult = ITIPHandler::ResultError;
		expectedNumIncidences = 0;
		action = QLatin1String("accepted");
		QTest::newRow("invalid data") << QString() << action << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		// Testing invalid action
		expectedResult = ITIPHandler::ResultError;
		data_filename = QLatin1String("invitation_us");
		expectedNumIncidences = 0;
		action = QLatin1String("accepted");
		QTest::newRow("invalid action") << data_filename << QString() << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		// Test bug 235749
		expectedResult = ITIPHandler::ResultSuccess;
		data_filename = QLatin1String("bug235749");
		expectedNumIncidences = 1;
		expectedPartStat = KCalCore::Attendee::Accepted;
		action = QLatin1String("accepted");
		incidenceUid = QLatin1String("b6f0466a-8877-49d0-a4fc-8ee18ffd8e07"); // Don't change, hardcoded in data file
		QTest::newRow("bug 235749") << data_filename << action << receiver << incidenceUid
		<< expectedResult
		<< expectedNumIncidences
		<< expectedPartStat;
		//----------------------------------------------------------------------------------------------
		}

void ITIPHandlerTest::testProcessITIPMessage_data()		void ITIPHandlerTest::testProcessITIPMessage_data()
{		{
QTest::addColumn<QString>("data_filename");		QTest::addColumn<QString>("data_filename");
QTest::addColumn<QString>("action");		QTest::addColumn<QString>("action");
QTest::addColumn<QString>("receiver");		QTest::addColumn<QString>("receiver");
QTest::addColumn<QString>("incidenceUid"); // uid of incidence in invitation		QTest::addColumn<QString>("incidenceUid"); // uid of incidence in invitation
QTest::addColumn<Akonadi::ITIPHandler::Result>("expectedResult");		QTest::addColumn<Akonadi::ITIPHandler::Result>("expectedResult");
QTest::addColumn<int>("expectedNumIncidences");		QTest::addColumn<int>("expectedNumIncidences");
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines	void ITIPHandlerTest::testProcessITIPMessage()
QFETCH(int, expectedNumIncidences);		QFETCH(int, expectedNumIncidences);
QFETCH(KCalCore::Attendee::PartStat, expectedPartStat);		QFETCH(KCalCore::Attendee::PartStat, expectedPartStat);

FakeMessageQueueJob::sUnitTestResults.clear();		FakeMessageQueueJob::sUnitTestResults.clear();
createITIPHandler();		createITIPHandler();

m_expectedResult = expectedResult;		m_expectedResult = expectedResult;

		processItip(iCalData, receiver, action, expectedNumIncidences, items);

		if (expectedNumIncidences == 1) {
		KCalCore::Incidence::Ptr incidence = items.first().payload<KCalCore::Incidence::Ptr>();
		QVERIFY(incidence);
		QCOMPARE(incidence->schedulingID(), incidenceUid);
		QVERIFY(incidence->schedulingID() != incidence->uid());
		knaussAuthorUnsubmitted Not Done Inline Actions Well I would say, that the uid matches with the schedulingId. Otherwise we can't detect the event anymore with wallace/rcm, if they are different. knauss: Well I would say, that the uid matches with the schedulingId. Otherwise we can't detect the…

		KCalCore::Attendee::Ptr me = ourAttendee(incidence);
		QVERIFY(me);
		QCOMPARE(me->status(), expectedPartStat);
		}

		cleanup();
		}

		void ITIPHandlerTest::testProcessITIPMessageUpdate()
		{
		QFETCH(QString, data_filename);
		QFETCH(QString, action);
		QFETCH(QString, receiver);
		QFETCH(QString, incidenceUid);
		QFETCH(Akonadi::ITIPHandler::Result, expectedResult);
		QFETCH(int, expectedNumIncidences);
		QFETCH(KCalCore::Attendee::PartStat, expectedPartStat);

		FakeMessageQueueJob::sUnitTestResults.clear();
		createITIPHandler();

		m_expectedResult = expectedResult;

QString iCalData = icalData(data_filename);		QString iCalData = icalData(data_filename);
Akonadi::Item::List items;		Akonadi::Item::List items;
		KCalCore::MemoryCalendar::Ptr expectedCalendar = KCalCore::MemoryCalendar::Ptr(new KCalCore::MemoryCalendar(KDateTime::UTC));
		KCalCore::ICalFormat format;
		format.fromString(expectedCalendar, iCalData);

		if (!iCalData.isEmpty()) { //Create starting data as akonadi item to test update
		Akonadi::Item item;
		const KCalCore::Incidence::Ptr inc = expectedCalendar->incidences().first();
		item.setMimeType(KCalCore::Event::eventMimeType());
		item.setPayload<KCalCore::Incidence::Ptr>(inc);
		createIncidence(item);
		QCOMPARE(calendarItems().count(), 1);
		}
processItip(iCalData, receiver, action, expectedNumIncidences, items);		processItip(iCalData, receiver, action, expectedNumIncidences, items);

if (expectedNumIncidences == 1) {		if (expectedNumIncidences == 1) {
KCalCore::Incidence::Ptr incidence = items.first().payload<KCalCore::Incidence::Ptr>();		KCalCore::Incidence::Ptr incidence = items.first().payload<KCalCore::Incidence::Ptr>();
		cleanup();
QVERIFY(incidence);		QVERIFY(incidence);
QCOMPARE(incidence->schedulingID(), incidenceUid);		QCOMPARE(incidence->schedulingID(), incidenceUid);
QVERIFY(incidence->schedulingID() != incidence->uid());		QCOMPARE(incidence->schedulingID(), incidence->uid());

KCalCore::Attendee::Ptr me = ourAttendee(incidence);		KCalCore::Attendee::Ptr me = ourAttendee(incidence);
QVERIFY(me);		QVERIFY(me);
QCOMPARE(me->status(), expectedPartStat);		QCOMPARE(me->status(), expectedPartStat);
}		}

cleanup();		cleanup();
}		}
Show All 34 Lines	void ITIPHandlerTest::testProcessITIPMessages_data()
invitation_filenames << QLatin1String("invited_us_daily") << QLatin1String("invited_us_daily_cancel_recid01");		invitation_filenames << QLatin1String("invited_us_daily") << QLatin1String("invited_us_daily_cancel_recid01");
expected_filename = QLatin1String("expected_data/cancel1");		expected_filename = QLatin1String("expected_data/cancel1");
actions << QLatin1String("accepted") << QLatin1String("cancel");		actions << QLatin1String("accepted") << QLatin1String("cancel");
QTest::newRow("accept recid cancel") << invitation_filenames << expected_filename << actions;		QTest::newRow("accept recid cancel") << invitation_filenames << expected_filename << actions;

//----------------------------------------------------------------------------------------------		//----------------------------------------------------------------------------------------------
}		}

		void ITIPHandlerTest::testProcessITIPMessagesUpdate_data()
		{
		testProcessITIPMessages_data();
		}

void ITIPHandlerTest::testProcessITIPMessages()		void ITIPHandlerTest::testProcessITIPMessages()
{		{
QFETCH(QStringList, invitation_filenames);		QFETCH(QStringList, invitation_filenames);
QFETCH(QString, expected_filename);		QFETCH(QString, expected_filename);
QFETCH(QStringList, actions);		QFETCH(QStringList, actions);

const QString receiver = QLatin1String(s_ourEmail);		const QString receiver = QLatin1String(s_ourEmail);

Show All 15 Lines	void ITIPHandlerTest::testProcessITIPMessages()
KCalCore::MemoryCalendar::Ptr expectedCalendar = KCalCore::MemoryCalendar::Ptr(new KCalCore::MemoryCalendar(KDateTime::UTC));		KCalCore::MemoryCalendar::Ptr expectedCalendar = KCalCore::MemoryCalendar::Ptr(new KCalCore::MemoryCalendar(KDateTime::UTC));
KCalCore::ICalFormat format;		KCalCore::ICalFormat format;
format.fromString(expectedCalendar, expectedICalData);		format.fromString(expectedCalendar, expectedICalData);
compareCalendars(expectedCalendar); // Here's where the cool and complex comparations are done		compareCalendars(expectedCalendar); // Here's where the cool and complex comparations are done

cleanup();		cleanup();
}		}

		void ITIPHandlerTest::testProcessITIPMessagesUpdate()
		{
		QFETCH(QStringList, invitation_filenames);
		QFETCH(QString, expected_filename);
		QFETCH(QStringList, actions);

		const QString receiver = QLatin1String(s_ourEmail);

		FakeMessageQueueJob::sUnitTestResults.clear();
		createITIPHandler();

		m_expectedResult = Akonadi::ITIPHandler::ResultSuccess;

		{ //create first invitation as akonadi item, to test if the update process is working
		const QString iCalData = icalData(invitation_filenames.first());
		KCalCore::MemoryCalendar::Ptr expectedCalendar = KCalCore::MemoryCalendar::Ptr(new KCalCore::MemoryCalendar(KDateTime::UTC));
		KCalCore::ICalFormat format;
		format.fromString(expectedCalendar, iCalData);

		Akonadi::Item item;
		const KCalCore::Incidence::Ptr inc = expectedCalendar->incidences().first();
		item.setMimeType(KCalCore::Event::eventMimeType());
		item.setPayload<KCalCore::Incidence::Ptr>(inc);
		createIncidence(item);
		QCOMPARE(calendarItems().count(), 1);
		}

		for (int i=0; i<invitation_filenames.count(); i++) {
		// First accept the invitation that creates the incidence:
		QString iCalData = icalData(invitation_filenames.at(i));
		Item::List items;
		qDebug() << "Processing " << invitation_filenames.at(i);
		processItip(iCalData, receiver, actions.at(i), -1, items);
		}


		QString expectedICalData = icalData(expected_filename);
		KCalCore::MemoryCalendar::Ptr expectedCalendar = KCalCore::MemoryCalendar::Ptr(new KCalCore::MemoryCalendar(KDateTime::UTC));
		KCalCore::ICalFormat format;
		format.fromString(expectedCalendar, expectedICalData);
		compareCalendars(expectedCalendar); // Here's where the cool and complex comparations are done

		cleanup();
		}

void ITIPHandlerTest::testProcessITIPMessageCancel_data()		void ITIPHandlerTest::testProcessITIPMessageCancel_data()
{		{
QTest::addColumn<QString>("creation_data_filename"); // filename to create incidence		QTest::addColumn<QString>("creation_data_filename"); // filename to create incidence
QTest::addColumn<QString>("cancel_data_filename"); // filename with incidence cancelation		QTest::addColumn<QString>("cancel_data_filename"); // filename with incidence cancelation
QTest::addColumn<QString>("incidenceUid"); // uid of incidence in invitation		QTest::addColumn<QString>("incidenceUid"); // uid of incidence in invitation


QString creation_data_filename;		QString creation_data_filename;
▲ Show 20 Lines • Show All 213 Lines • ▼ Show 20 Lines	case IncidenceChanger::ChangeTypeDelete:
// Create if first, so we have something to delete		// Create if first, so we have something to delete
m_changer->setGroupwareCommunication(false);		m_changer->setGroupwareCommunication(false);
m_changer->createIncidence(incidence, mCollection);		m_changer->createIncidence(incidence, mCollection);
waitForIt();		waitForIt();
m_changer->setGroupwareCommunication(true);		m_changer->setGroupwareCommunication(true);
QCOMPARE(FakeMessageQueueJob::sUnitTestResults.count(), 0);		QCOMPARE(FakeMessageQueueJob::sUnitTestResults.count(), 0);

QVERIFY(mLastInsertedItem.isValid());		QVERIFY(mLastInsertedItem.isValid());
		QCOMPARE(calendarItems().count(), 1);

m_pendingIncidenceChangerSignal = 1;		m_pendingIncidenceChangerSignal = 1;
m_changer->deleteIncidence(mLastInsertedItem);		m_changer->deleteIncidence(mLastInsertedItem);
waitForIt();		waitForIt();
QCOMPARE(FakeMessageQueueJob::sUnitTestResults.count(), expectedEmailCount);		QCOMPARE(FakeMessageQueueJob::sUnitTestResults.count(), expectedEmailCount);
break;		break;
default:		default:
Q_ASSERT(false);		Q_ASSERT(false);
}		}
		cleanup();
}		}

void ITIPHandlerTest::testIdentity_data()		void ITIPHandlerTest::testIdentity_data()
{		{
QTest::addColumn<QString>("email");		QTest::addColumn<QString>("email");
QTest::addColumn<bool>("expectedResult");		QTest::addColumn<bool>("expectedResult");

const QString myEmail = QLatin1String(s_ourEmail);		const QString myEmail = QLatin1String(s_ourEmail);
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines