Fixed keySignVerifyTest.
[accounts-sso:accounts-qt.git] / tests / accountstest.cpp
1 /* vi: set et sw=4 ts=4 cino=t0,(0: */
2 /*
3  * This file is part of libaccounts-qt
4  *
5  * Copyright (C) 2009-2010 Nokia Corporation.
6  *
7  * Contact: Alberto Mardegan <alberto.mardegan@nokia.com>
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public License
11  * version 2.1 as published by the Free Software Foundation.
12  *
13  * This library is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21  * 02110-1301 USA
22  */
23 #include <QtTest/QtTest>
24
25 #include "Accounts/Manager"
26
27 using namespace Accounts;
28 #include "accountstest.h"
29
30 #define PROVIDER QString("dummyprovider")
31 #define SERVICE QString("dummyservice")
32 #define MYSERVICE QLatin1String("MyService")
33 #define OTHERSERVICE QLatin1String("OtherService")
34 #define EMAIL_SERVICE_TYPE QLatin1String("e-mail")
35
36
37 void clearDb()
38 {
39     QDir dbroot(QString(getenv("ACCOUNTS")));
40     dbroot.remove(QString("accounts.db"));
41 }
42
43 void AccountsTest::initTestCase()
44 {
45     //init
46     setenv ("ACCOUNTS", "/tmp/", TRUE);
47     setenv ("AG_SERVICES", SERVICES_DIR, TRUE);
48     setenv ("AG_SERVICE_TYPES", SERVICE_TYPES_DIR, TRUE);
49     setenv ("AG_PROVIDERS", PROVIDERS_DIR, TRUE);
50     //clear database
51     clearDb();
52 }
53
54 void AccountsTest::cleanupTestCase()
55 {
56 }
57
58
59 /* manager */
60 void AccountsTest::managerTestCase()
61 {
62     Manager * mgr=new Manager();
63     QVERIFY(mgr!=NULL);
64     delete mgr;
65 }
66
67 void AccountsTest::createAccountTestCase()
68 {
69     clearDb();
70
71     Manager * mgr=new Manager();
72     QVERIFY(mgr!=NULL);
73
74     Account *account = mgr->createAccount(NULL);
75     QVERIFY(account!=NULL);
76     QVERIFY(account->manager() == mgr);
77     delete account;
78
79     account = mgr->createAccount(PROVIDER);
80     QVERIFY(account!=NULL);
81     delete account;
82
83     delete mgr;
84 }
85
86 void AccountsTest::accountTestCase()
87 {
88     clearDb();
89
90     Manager * mgr=new Manager();
91     QVERIFY(mgr!=NULL);
92
93     //this should not exist
94     Account* account2 = mgr->account(1);
95     QVERIFY(account2==NULL);
96     Error error = mgr->lastError();
97     QCOMPARE(error.type(), Error::AccountNotFound);
98
99     // make sure there is account
100     Account* account = mgr->createAccount(NULL);
101     account->sync();
102
103     //now we get account
104     account2 = mgr->account(1);
105     QVERIFY(account2!=NULL);
106
107     delete account2;
108     delete account;
109     delete mgr;
110 }
111
112 void AccountsTest::accountListTestCase()
113 {
114     clearDb();
115
116     Manager * mgr=new Manager();
117     QVERIFY(mgr!=NULL);
118
119     // make sure there is account
120     Account* account = mgr->createAccount(NULL);
121     account->sync();
122
123     AccountIdList list = mgr->accountList(NULL);
124
125     QVERIFY(!list.isEmpty());
126     QCOMPARE(list.size(), 1);
127
128     for (int i = 0; i < list.size(); i++) {
129          qDebug("%d : %d",i,list.at(i));
130      }
131
132     delete account;
133     delete mgr;
134 }
135
136 void AccountsTest::providerTestCase()
137 {
138     Manager * mgr=new Manager();
139     QVERIFY(mgr!=NULL);
140
141     Account *account = mgr->createAccount(PROVIDER);
142     QVERIFY(account!=NULL);
143
144     QString provider_name = account->providerName();
145     QCOMPARE(provider_name, PROVIDER);
146
147     delete account;
148
149     /* Check listing and loading of XML files */
150     Provider *provider = mgr->provider("MyProvider");
151     QVERIFY(provider != NULL);
152
153     QCOMPARE(provider->displayName(), QString("My Provider"));
154
155     ProviderList providers = mgr->providerList();
156     QVERIFY(!providers.isEmpty());
157     QVERIFY(providers.size() == 1);
158     QCOMPARE(providers[0]->displayName(), QString("My Provider"));
159
160     delete mgr;
161 }
162
163 void AccountsTest::serviceTestCase()
164 {
165     Manager * mgr=new Manager();
166     QVERIFY(mgr!=NULL);
167
168     Service* service = mgr->service(MYSERVICE);
169     QVERIFY(service!=NULL);
170     QCOMPARE(service->name(), MYSERVICE);
171
172     service = mgr->service(SERVICE);
173     QVERIFY(service==NULL);
174
175     delete mgr;
176 }
177
178 void AccountsTest::serviceListTestCase()
179 {
180     Manager * mgr=new Manager();
181     QVERIFY(mgr!=NULL);
182
183     ServiceList list = mgr->serviceList();
184     QVERIFY(!list.isEmpty());
185     QVERIFY(list.size()==2);
186
187     for (int i = 0; i < list.size(); i++) {
188          qDebug("%d : %s",i,((Service*)list.at(i))->name().toLocal8Bit().constData());
189      }
190
191     delete mgr;
192 }
193
194 /* service */
195
196 void AccountsTest::serviceConstTestCase()
197 {
198     Manager * mgr=new Manager();
199     QVERIFY(mgr!=NULL);
200
201     Service* service = mgr->service(MYSERVICE);
202     QVERIFY(service!=NULL);
203     QCOMPARE(service->name(), MYSERVICE);
204     QCOMPARE(service->displayName(), QString("My Service"));
205     QCOMPARE(service->serviceType(), QString("e-mail"));
206     QCOMPARE(service->provider(), QString(""));
207     QVERIFY(service->service()!=NULL);
208
209     delete mgr;
210 }
211
212
213 /* account */
214
215
216 void AccountsTest::accountConstTestCase()
217 {
218     Manager * mgr=new Manager();
219     QVERIFY(mgr!=NULL);
220
221     Account *account = mgr->createAccount(PROVIDER);
222     QVERIFY(account!=NULL);
223
224     delete account;
225     delete mgr;
226 }
227
228 void AccountsTest::accountServiceTestCase()
229 {
230     Manager * mgr=new Manager();
231     QVERIFY(mgr!=NULL);
232
233     Account *account = mgr->createAccount(PROVIDER);
234     QVERIFY(account!=NULL);
235
236     //TODO not implemented yet
237     QVERIFY(!account->supportsService(QString("unsupported")));
238     //QVERIFY(account->supportsService(QString("e-mail")));
239
240     //TODO not implemented yet
241     ServiceList list = account->services();
242     //QVERIFY(!list.isEmpty());
243     //QVERIFY(list.size()==2);
244     for (int i = 0; i < list.size(); i++) {
245          qDebug("%d : %s",i,((Service*)list.at(i))->name().toLocal8Bit().constData());
246      }
247
248     delete account;
249     delete mgr;
250 }
251
252
253 void AccountsTest::enabled(const QString & /*serviceName*/, bool enabled)
254 {
255     m_enabled = enabled;
256 }
257
258
259 void AccountsTest::accountEnabledTestCase()
260 {
261     Manager * mgr=new Manager();
262     QVERIFY(mgr!=NULL);
263
264     Account *account = mgr->createAccount(PROVIDER);
265     QVERIFY(account!=NULL);
266     m_enabled=false;
267     QObject::connect(account, SIGNAL(enabledChanged(const QString&,bool)),
268                       this,  SLOT(enabled(const QString&,bool)));
269
270     account->setEnabled(true);
271     account->sync();
272     QVERIFY(account->enabled());
273     QVERIFY(m_enabled);
274     account->setEnabled(false);
275     account->sync();
276     QVERIFY(!account->enabled());
277     QVERIFY(!m_enabled);
278
279     delete account;
280     delete mgr;
281 }
282
283 void AccountsTest::display(const QString &displayName)
284 {
285     m_enabled = !displayName.isNull();
286 }
287
288 void AccountsTest::accountDisplayNameTestCase()
289 {
290     Manager * mgr=new Manager();
291     QVERIFY(mgr!=NULL);
292
293     Account *account = mgr->createAccount(PROVIDER);
294     QVERIFY(account!=NULL);
295     m_enabled=false;
296     QObject::connect(account, SIGNAL(displayNameChanged(const QString&)),
297                       this,  SLOT(display(const QString&)));
298
299     account->setDisplayName(PROVIDER);
300     account->sync();
301     QCOMPARE(account->displayName(),PROVIDER);
302     QVERIFY(m_enabled);
303
304     delete account;
305     delete mgr;
306 }
307
308
309
310 void AccountsTest::accountValueTestCase()
311 {
312     Manager * mgr=new Manager();
313     QVERIFY(mgr!=NULL);
314
315     Account *account = mgr->createAccount(PROVIDER);
316     QVERIFY(account!=NULL);
317
318     QObject::connect(account, SIGNAL(synced()),
319                       this,  SLOT(stored()));
320     m_stored = false;
321     account->setValue(QString("test"),QString("value"));
322     int int_value = 666;
323     account->setValue("testint", int_value);
324     account->sync();
325
326     QVERIFY(m_stored);
327
328     /* check that the values we wrote are retrieved successfully */
329     QVariant val = QVariant::String;
330     account->value(QString("test"), val);
331     QCOMPARE(val.toString(), QString("value"));
332
333     SettingSource source;
334     source = account->value(QString("test"), val);
335     QCOMPARE(val.toString(), QString("value"));
336
337     QVariant intval = QVariant::Int;
338     account->value("testint", intval);
339     qDebug("Val: %d", intval.toInt());
340     QVERIFY(intval.toInt() == int_value);
341
342     QVERIFY(source == ACCOUNT);
343
344     /* test the convenience methods */
345     QString strval = account->valueAsString("test");
346     QCOMPARE (strval, QString("value"));
347
348     strval = account->valueAsString("test_unexisting", "hello");
349     QCOMPARE (strval, QString("hello"));
350
351     delete account;
352     delete mgr;
353 }
354
355
356 void AccountsTest::stored()
357 {
358     qDebug("%s %d %s:\t", __FILE__, __LINE__, __func__);
359     TRACE();
360     m_stored = true;
361 }
362
363 void AccountsTest::error(Accounts::Error error)
364 {
365     qDebug("%s %d %s:\t", __FILE__, __LINE__, __func__);
366     TRACE() << "error:" << error.type();
367     m_stored = false;
368 }
369
370
371 void AccountsTest::accountSyncTestCase()
372 {
373     Manager * mgr=new Manager();
374     QVERIFY(mgr!=NULL);
375
376     Account *account = mgr->createAccount(PROVIDER);
377     QVERIFY(account!=NULL);
378
379     QString provider = account->providerName();
380     QCOMPARE(provider, PROVIDER);
381
382     m_stored = false;
383     QObject::connect(account, SIGNAL(synced()),
384                       this,  SLOT(stored()));
385
386     account->sync();
387     QVERIFY(m_stored);
388
389     delete account;
390     delete mgr;
391 }
392
393 void AccountsTest::created(Accounts::AccountId id)
394 {
395     m_created = id;
396 }
397
398 void AccountsTest::createdTestCase()
399 {
400     Manager *mgr = new Manager();
401     QVERIFY(mgr != NULL);
402
403     m_created = 0;
404     QObject::connect(mgr, SIGNAL(accountCreated(Accounts::AccountId)),
405                      this, SLOT(created(Accounts::AccountId)));
406
407     Account *account = mgr->createAccount(NULL);
408     QVERIFY(account != NULL);
409
410     /* store the account: this will emit accountCreated */
411     account->sync();
412     QVERIFY(m_created != 0);
413     QVERIFY(m_created == account->id());
414
415     delete account;
416     delete mgr;
417 }
418
419 void AccountsTest::removed()
420 {
421     m_removed = true;
422 }
423
424 void AccountsTest::removeTestCase()
425 {
426     Manager *mgr = new Manager();
427     QVERIFY(mgr != NULL);
428
429     Account *account = mgr->createAccount(NULL);
430     QVERIFY(account != NULL);
431
432     /* store the account */
433     account->sync();
434     QVERIFY(account->id() != 0);
435
436     m_removed = false;
437     QObject::connect(account, SIGNAL(removed()), this, SLOT(removed()));
438
439     /* mark the account for deletion -- and make sure it's not deleted
440      * immediately */
441     account->remove ();
442     QVERIFY(m_removed == false);
443
444     /* store the changes */
445     account->sync();
446     QVERIFY(m_removed == true);
447
448     delete account;
449     delete mgr;
450 }
451
452 void AccountsTest::w_server_notify(const char *key)
453 {
454     qDebug() << __func__ << ", key = " << key;
455     m_server_notify++;
456 }
457
458 void AccountsTest::w_port_notify(const char *key)
459 {
460     qDebug() << __func__ << ", key = " << key;
461     m_port_notify++;
462 }
463
464 void AccountsTest::w_parameters_notify(const char *key)
465 {
466     qDebug() << __func__ << ", key = " << key;
467     m_parameters_notify++;
468 }
469
470 void AccountsTest::watchesTest()
471 {
472     Manager *mgr = new Manager();
473     QVERIFY (mgr != NULL);
474
475     Service* service = mgr->service(MYSERVICE);
476     QVERIFY(service != NULL);
477
478     /* create an account and some watches */
479     Account *account = mgr->createAccount(NULL);
480     QVERIFY(account != NULL);
481
482     account->selectService(service);
483
484     Watch *w_server = account->watchKey("parameters/server");
485     QObject::connect(w_server, SIGNAL(notify(const char *)),
486                      this, SLOT(w_server_notify(const char *)));
487
488     /* test also beginGroup() */
489     account->beginGroup("parameters");
490     QVERIFY(account->group() == "parameters");
491
492     Watch *w_parameters = account->watchKey(); /* watch the whole group */
493     QObject::connect(w_parameters, SIGNAL(notify(const char *)),
494                      this, SLOT(w_parameters_notify(const char *)));
495
496     Watch *w_port = account->watchKey("port");
497     QObject::connect(w_port, SIGNAL(notify(const char *)),
498                      this, SLOT(w_port_notify(const char *)));
499
500     /* now, change some values */
501     account->setValue("server", QString("xxx.nokia.com"));
502
503     /* reset the counters */
504     m_server_notify = 0;
505     m_port_notify = 0;
506     m_parameters_notify = 0;
507
508     /* write the data */
509     account->sync();
510
511     /* ensure that the callbacks have been called the correct number of times */
512     QVERIFY(m_server_notify == 1);
513     QVERIFY(m_parameters_notify == 1);
514     QVERIFY(m_port_notify == 0);
515
516     /* now change the port and another parameter not being watched */
517     account->setValue("port", 45);
518     account->endGroup(); /* exit from the "parameters/" prefix */
519     account->setValue("username", QString("h4ck3r@nokia.com"));
520
521     /* reset the counters */
522     m_server_notify = 0;
523     m_port_notify = 0;
524     m_parameters_notify = 0;
525
526     /* write the data */
527     account->sync();
528
529     /* ensure that the callbacks have been called the correct number of times */
530     QVERIFY(m_server_notify == 0);
531     QVERIFY(m_parameters_notify == 1);
532     QVERIFY(m_port_notify == 1);
533
534     /* change port and server, but delete the w_port watch */
535     delete w_port;
536
537     account->beginGroup("parameters");
538     account->setValue("port", 56);
539     account->setValue("server", QString("warez.nokia.com"));
540
541     /* reset the counters */
542     m_server_notify = 0;
543     m_port_notify = 0;
544     m_parameters_notify = 0;
545
546     /* write the data */
547     account->sync();
548
549     /* ensure that the callbacks have been called the correct number of times */
550     QVERIFY(m_server_notify == 1);
551     QVERIFY(m_parameters_notify == 1);
552     QVERIFY(m_port_notify == 0);
553
554
555     delete account;
556     delete mgr;
557 }
558
559 void AccountsTest::serviceDataTest()
560 {
561     Manager *mgr = new Manager();
562     QVERIFY (mgr != NULL);
563
564     Service* service = mgr->service(MYSERVICE);
565     QVERIFY(service != NULL);
566
567     QXmlStreamReader *xml = service->xmlStreamReader();
568     QVERIFY(xml != NULL);
569
570     QVERIFY(xml->readNext() == QXmlStreamReader::StartElement);
571     QVERIFY(xml->name() == QString("type_data"));
572
573     delete xml;
574     delete mgr;
575 }
576
577 void AccountsTest::settingsTest()
578 {
579     Manager *mgr = new Manager();
580     QVERIFY (mgr != NULL);
581
582     /* create an account and some watches */
583     Account *account = mgr->createAccount(NULL);
584     QVERIFY(account != NULL);
585
586     /* create a few keys/groups */
587     account->setValue("username", QString("fool"));
588     account->setValue("email", QString("fool@domain.com"));
589
590     account->beginGroup("parameters");
591     account->setValue("server", QString("xxx.nokia.com"));
592     account->setValue("port", 80);
593
594     account->beginGroup("proxy"); /* this is a subgroup of "parameters" */
595     account->setValue("use", true);
596     account->setValue("address", QString("proxy.nokia.com"));
597     QCOMPARE(account->group(), QString("parameters/proxy"));
598     account->endGroup();
599
600     QCOMPARE(account->group(), QString("parameters"));
601     account->endGroup();
602
603     /* write another top-level key */
604     account->setValue("verified", false);
605
606     /* re-enter a group */
607     account->beginGroup("preferences");
608     account->setValue("maximized", true);
609     account->setValue("initial_directory", QString("xxx"));
610     QCOMPARE(account->group(), QString("preferences"));
611     account->endGroup();
612
613     /* write the data */
614     account->sync();
615
616     /* now check if the groups and keys are layed out as expected */
617     QStringList expected;
618     QStringList result;
619
620     /* check allKeys() */
621     expected << "username" << "email" << "verified" <<
622         "parameters/server" << "parameters/port" <<
623         "parameters/proxy/use" << "parameters/proxy/address" <<
624         "preferences/maximized" << "preferences/initial_directory";
625     result = account->allKeys();
626
627     expected.sort();
628     result.sort();
629     QCOMPARE(result, expected);
630
631     /* check childGroups() */
632     expected.clear();
633     expected << "parameters" << "preferences";
634     result = account->childGroups();
635
636     expected.sort();
637     result.sort();
638     QCOMPARE(result, expected);
639
640     /* check childKeys() */
641     expected.clear();
642     expected << "username" << "email" << "verified";
643     result = account->childKeys();
644
645     expected.sort();
646     result.sort();
647     QCOMPARE(result, expected);
648
649
650     /* now enter a group and test the same methods as above */
651     account->beginGroup("parameters");
652
653     /* allKeys */
654     expected.clear();
655     expected << "server" << "port" << "proxy/use" << "proxy/address";
656     result = account->allKeys();
657
658     expected.sort();
659     result.sort();
660     QCOMPARE(result, expected);
661
662     /* childGroups */
663     expected.clear();
664     expected << "proxy";
665     result = account->childGroups();
666
667     expected.sort();
668     result.sort();
669     QCOMPARE(result, expected);
670
671     /* childKeys() */
672     expected.clear();
673     expected << "server" << "port";
674     result = account->childKeys();
675
676     expected.sort();
677     result.sort();
678     QCOMPARE(result, expected);
679
680     /* contains() */
681     QVERIFY(account->contains("server") == true);
682     QVERIFY(account->contains("unexisting") == false);
683
684     /* test remove() */
685     account->remove(""); /* remove all the parameters/ group */
686     account->endGroup();
687     account->remove("verified");
688
689     /* we need to sync, for the changes to take effect */
690     account->sync();
691
692     expected.clear();
693     expected << "username" << "email" <<
694         "preferences/maximized" << "preferences/initial_directory";
695     result = account->allKeys();
696
697     expected.sort();
698     result.sort();
699     QCOMPARE(result, expected);
700
701     /* Test clear(): call it from inside the preferences/ group */
702     account->beginGroup("preferences");
703     account->clear();
704     account->sync();
705
706     expected.clear(); /* all keys should have been deleted */
707     result = account->allKeys();
708
709     expected.sort();
710     result.sort();
711     QCOMPARE(result, expected);
712
713     delete account;
714     delete mgr;
715 }
716
717 void AccountsTest::keySignVerifyTest()
718 {
719 #ifndef HAVE_AEGISCRYPTO
720     QSKIP("aegis-crypto not detected.", SkipSingle);
721 #endif
722
723     const QString key = "key";
724     const char *token;
725     QList<const char*> listOfTokens;
726     listOfTokens << "libaccounts-glib0::accounts-glib-access"
727                  << "libaccounts-glib0::dummy"
728                  << "libaccounts-glib0::idiotic";
729     bool ok;
730
731     Manager *mgr = new Manager();
732     QVERIFY (mgr != NULL);
733
734     Account *account = mgr->createAccount(NULL);
735     QVERIFY(account != NULL);
736
737     account->setValue(key, QString("the key value"));
738     account->syncAndBlock();
739
740     account->sign(key, listOfTokens.at(0));
741     account->syncAndBlock();
742
743     ok = account->verify(key, &token);
744     QVERIFY(ok == true);
745
746     ok = account->verifyWithTokens(key, listOfTokens);
747     QVERIFY(ok == true);
748 }
749
750 void AccountsTest::incrementalAccountIdsTest()
751 {
752     clearDb();
753
754     Manager * mgr = new Manager;
755     QVERIFY(mgr != NULL);
756
757     Account *account = mgr->createAccount(NULL);
758     QVERIFY(account != NULL);
759     QVERIFY(account->manager() == mgr);
760     account->syncAndBlock();
761     AccountId lastId = account->id();
762
763     account->remove();
764     account->syncAndBlock();
765     delete account;
766
767     account = mgr->createAccount(NULL);
768     QVERIFY(account != NULL);
769     QVERIFY(account->manager() == mgr);
770     account->syncAndBlock();
771
772     QCOMPARE(account->id(), lastId + 1);
773
774     delete account;
775     delete mgr;
776 }
777
778 void AccountsTest::selectGlobalAccountSettingsTest()
779 {
780     Manager *mgr = new Manager;
781     QVERIFY(mgr != NULL);
782
783     Account *account = mgr->createAccount("MyProvider");
784     QVERIFY(account != NULL);
785     QVERIFY(account->manager() == mgr);
786
787     account->syncAndBlock();
788     QVERIFY(account->id() > 0);
789
790     account->selectService();
791     Service *selectedService = account->selectedService();
792     QVERIFY(selectedService == NULL);
793 }
794
795 void AccountsTest::credentialsIdTest()
796 {
797     Manager *mgr = new Manager;
798     QVERIFY(mgr != NULL);
799
800     Account *account = mgr->createAccount("MyProvider");
801     QVERIFY(account != NULL);
802
803     Service* service = mgr->service(MYSERVICE);
804     QVERIFY(service != NULL);
805
806     qint32 globalId = 69, myServiceId = 0xDEAD;
807
808     account->setCredentialsId(globalId);
809
810     account->selectService(service);
811     account->setCredentialsId(myServiceId);
812
813     account->syncAndBlock();
814     QVERIFY(account->id() != 0);
815
816     QCOMPARE(account->credentialsId(), myServiceId);
817
818     /* select a service with no credentials: we should get the global
819      * credentials ID, but the selected service shouldn't change */
820     service = mgr->service(OTHERSERVICE);
821     QVERIFY(service != NULL);
822
823     account->selectService(service);
824     QCOMPARE(account->credentialsId(), globalId);
825     QCOMPARE(account->selectedService(), service);
826
827     /* now make sure that we can get the ID from the global accounts settings */
828     account->selectService(NULL);
829     QCOMPARE(account->credentialsId(), globalId);
830 }
831
832 void AccountsTest::listEnabledServices()
833 {
834     clearDb();
835
836     Manager *mgr = new Manager();
837     QVERIFY(mgr != NULL);
838
839     Service* service = mgr->service(MYSERVICE);
840     QVERIFY(service!=NULL);
841
842     Account* account = mgr->createAccount("MyProvider");
843     QVERIFY(account != NULL);
844     account->selectService(service);
845     account->setEnabled(true);
846     account->sync();
847
848     ServiceList list = account->enabledServices();
849     QVERIFY(!list.isEmpty());
850     QCOMPARE(list.size(), 1);
851
852     account->selectService(service);
853     account->setEnabled(false);
854     account->sync();
855
856     list = account->enabledServices();
857     QVERIFY(list.isEmpty());
858
859     delete account;
860     delete mgr;
861 }
862
863
864 void AccountsTest::listEnabledByServiceType()
865 {
866     clearDb();
867
868     Manager *mgr = new Manager("e-mail");
869     QVERIFY(mgr != NULL);
870
871     Account* account = mgr->createAccount("MyProvider");
872     QVERIFY(account != NULL);
873     account->setEnabled(true);
874
875     Service* service = mgr->service(MYSERVICE);
876     QVERIFY(service!=NULL);
877     account->selectService(service);
878     account->setEnabled(true);
879     account->sync();
880
881     AccountIdList list = mgr->accountListEnabled("e-mail");
882
883     QVERIFY(!list.isEmpty());
884     QCOMPARE(list.size(), 1);
885
886     account->setEnabled(false);
887     account->sync();
888
889     list = mgr->accountListEnabled("e-mail");
890     QVERIFY(list.isEmpty());
891
892     delete account;
893     delete mgr;
894 }
895
896 void AccountsTest::enabledEvent(Accounts::AccountId id)
897 {
898     m_enabledEvent = id;
899 }
900
901 void AccountsTest::enabledEvent()
902 {
903     Manager *mgr = new Manager("e-mail");
904     QVERIFY(mgr != NULL);
905
906     m_enabledEvent = 0;
907     QObject::connect(mgr, SIGNAL(enabledEvent(Accounts::AccountId)),
908                      this, SLOT(enabledEvent(Accounts::AccountId)));
909
910     Account *account = mgr->createAccount(NULL);
911     QVERIFY(account != NULL);
912     account->setEnabled(true);
913     account->sync();
914
915     QVERIFY(m_enabledEvent != 0);
916     QVERIFY(m_enabledEvent == account->id());
917
918     //if we create manager without service type the signal shoudl not be emitted
919     Manager *mgr2 = new Manager();
920     QVERIFY(mgr2 != NULL);
921
922     m_enabledEvent = 0;
923     QObject::connect(mgr2, SIGNAL(enabledEvent(Accounts::AccountId)),
924                      this, SLOT(enabledEvent(Accounts::AccountId)));
925
926     Account *account2 = mgr2->createAccount(NULL);
927     QVERIFY(account2 != NULL);
928     account2->setEnabled(true);
929     account2->sync();
930
931     QVERIFY(m_enabledEvent == 0);
932     QVERIFY(m_enabledEvent != account2->id());
933
934     delete account;
935     delete account2;
936     delete mgr;
937     delete mgr2;
938 }
939
940 void AccountsTest::serviceTypeTestCase()
941 {
942     Manager *mgr = new Manager();
943     QVERIFY(mgr != NULL);
944
945     ServiceType *serviceType;
946
947     serviceType = mgr->serviceType("unexisting-type");
948     QVERIFY(serviceType == NULL);
949
950     serviceType = mgr->serviceType(EMAIL_SERVICE_TYPE);
951     QVERIFY(serviceType != NULL);
952
953     QCOMPARE(serviceType->name(), EMAIL_SERVICE_TYPE);
954     QCOMPARE(serviceType->displayName(), QLatin1String("Electronic mail"));
955     QCOMPARE(serviceType->trCatalog(), QLatin1String("translation_file"));
956     QCOMPARE(serviceType->iconName(), QLatin1String("email_icon"));
957
958     delete mgr;
959 }
960
961 void AccountsTest::updateAccountTestCase()
962 {
963     clearDb();
964
965     Manager *mgr = new Manager("e-mail");
966     QVERIFY(mgr != NULL);
967
968     m_updateEvent = 0;
969     QObject::connect(mgr, SIGNAL(accountUpdated(Accounts::AccountId)),
970                      this, SLOT(updateAccount(Accounts::AccountId)));
971
972     Account *account = mgr->createAccount("MyProvider");
973     QVERIFY(account != NULL);
974     account->syncAndBlock();
975
976     Service* service = mgr->service(MYSERVICE);
977     QVERIFY(service!=NULL);
978     account->selectService(service);
979
980     account->setValue("key", QVariant("value"));
981     account->syncAndBlock();
982
983     QVERIFY(m_updateEvent != 0);
984     QVERIFY(m_updateEvent == account->id());
985
986     //if we create manager without service type the signal shoudl not be emitted
987     Manager *mgr2 = new Manager();
988     QVERIFY(mgr2 != NULL);
989
990     m_updateEvent = 0;
991     QObject::connect(mgr2, SIGNAL(accountUpdated(Accounts::AccountId)),
992                      this, SLOT(updateAccount(Accounts::AccountId)));
993
994     Account *account2 = mgr2->createAccount(NULL);
995     QVERIFY(account2 != NULL);
996
997     account2->setValue("key", QVariant("value"));
998     account2->syncAndBlock();
999
1000     QVERIFY(m_updateEvent == 0);
1001     QVERIFY(m_updateEvent != account2->id());
1002
1003     delete account;
1004     delete account2;
1005     delete mgr;
1006     delete mgr2;
1007 }
1008
1009 void AccountsTest::updateAccount(Accounts::AccountId id)
1010 {
1011     m_updateEvent = id;
1012 }
1013
1014 QTEST_MAIN(AccountsTest)
1015 // #include "testqstring.moc"