Fix failing test
[accounts-sso:signon.git] / tests / libsignon-qt-tests / testauthsession.cpp
1 /*
2  * This file is part of signon
3  *
4  * Copyright (C) 2009-2010 Nokia Corporation.
5  *
6  * Contact: Alberto Mardegan <alberto.mardegan@nokia.com>
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * version 2.1 as published by the Free Software Foundation.
11  *
12  * This library is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  */
22
23 #ifndef TESTAUTHSESSION_CPP_
24 #define TESTAUTHSESSION_CPP_
25
26 #include "testauthsession.h"
27 #include "testthread.h"
28 #include "SignOn/identity.h"
29
30 #define SSO_TEST_CREATE_AUTH_SESSION(__session__, __method__) \
31     do {                                                            \
32         Identity *id = Identity::newIdentity(IdentityInfo(), this); \
33         __session__ = id->createSession(QLatin1String(__method__)); \
34     } while(0)
35
36
37 static AuthSession *g_currentSession = NULL;
38 static QStringList g_processReplyRealmsList;
39 static int g_bigStringSize = 50000;
40 static int g_bigStringReplySize = 0;
41
42 void TestAuthSession::initTestCase()
43 {
44     qDebug() << "HI!";
45 }
46
47 void TestAuthSession::cleanupTestCase()
48 {
49     qDebug() << "BYE!";
50 }
51
52 void TestAuthSession::queryMechanisms_existing_method()
53 {
54     AuthSession *as;
55     SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
56
57     QStringList wantedMechs;
58
59     QSignalSpy spy(as, SIGNAL(mechanismsAvailable(const QStringList&)));
60     QSignalSpy errorCounter(as, SIGNAL(error(const SignOn::Error &)));
61     QEventLoop loop;
62
63     QObject::connect(as, SIGNAL(mechanismsAvailable(const QStringList&)), &loop, SLOT(quit()));
64     QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
65     QTimer::singleShot(10*1000, &loop, SLOT(quit()));
66
67     as->queryAvailableMechanisms(wantedMechs);
68
69     if(!errorCounter.count())
70         loop.exec();
71
72     errorCounter.clear();
73
74     QCOMPARE(spy.count(), 1);
75     QStringList result = spy.at(0).at(0).toStringList();
76     QCOMPARE(result.size(), 4);
77
78     wantedMechs += "mech1";
79
80     QTimer::singleShot(10*1000, &loop, SLOT(quit()));
81
82     as->queryAvailableMechanisms(wantedMechs);
83
84     if(!errorCounter.count())
85         loop.exec();
86
87     errorCounter.clear();
88
89     QCOMPARE(spy.count(), 2);
90     result = spy.at(1).at(0).toStringList();
91     QCOMPARE(result.size(), 1);
92
93     wantedMechs += "mech2";
94
95     QTimer::singleShot(10*1000, &loop, SLOT(quit()));
96
97     as->queryAvailableMechanisms(wantedMechs);
98
99     if(!errorCounter.count())
100         loop.exec();
101
102     errorCounter.clear();
103
104     QCOMPARE(spy.count(), 3);
105     result = spy.at(2).at(0).toStringList();
106     QCOMPARE(result.size(), 2);
107
108     wantedMechs = QStringList("fake");
109
110     QTimer::singleShot(10*1000, &loop, SLOT(quit()));
111
112     as->queryAvailableMechanisms(wantedMechs);
113
114     if(!errorCounter.count())
115         loop.exec();
116
117     errorCounter.clear();
118
119     QCOMPARE(spy.count(), 4);
120     result = spy.at(3).at(0).toStringList();
121     QCOMPARE(result.size(), 0);
122  }
123
124  void TestAuthSession::queryMechanisms_nonexisting_method()
125  {
126      AuthSession *as;
127      SSO_TEST_CREATE_AUTH_SESSION(as, "nonexisting");
128
129      QStringList wantedMechs;
130
131      QSignalSpy spy(as, SIGNAL(error(const SignOn::Error &)));
132      QEventLoop loop;
133
134      QObject::connect(as, SIGNAL(mechanismsAvailable(const QStringList&)), &loop, SLOT(quit()));
135      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
136      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
137
138      as->queryAvailableMechanisms(wantedMechs);
139      loop.exec();
140
141      QCOMPARE(spy.count(), 1);
142  }
143
144  void TestAuthSession::process_with_new_identity()
145  {
146      AuthSession *as;
147      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
148
149      g_processReplyRealmsList.clear();
150      connect(as, SIGNAL(response(const SignOn::SessionData &)), this, SLOT(response(const SignOn::SessionData &)));
151
152      QSignalSpy spy(as, SIGNAL(response(const SignOn::SessionData &)));
153      QSignalSpy errorCounter(as, SIGNAL(error(const SignOn::Error &)));
154      QSignalSpy stateCounter(as, SIGNAL(stateChanged(AuthSession::AuthSessionState, const QString&)));
155      QEventLoop loop;
156
157      QObject::connect(as, SIGNAL(response(const SignOn::SessionData &)), &loop, SLOT(quit()));
158      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
159      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
160
161      SessionData inData;
162
163      inData.setSecret("testSecret");
164      inData.setUserName("testUsername");
165
166      as->process(inData, "mech1");
167      if(!errorCounter.count())
168          loop.exec();
169
170      QCOMPARE(stateCounter.count(), 12);
171      stateCounter.clear();
172      errorCounter.clear();
173
174      as->process(inData, "mech1");
175      if(!errorCounter.count())
176          loop.exec();
177
178      QCOMPARE(stateCounter.count(), 12);
179      stateCounter.clear();
180      errorCounter.clear();
181
182      as->process(inData, "mech1");
183      if(!errorCounter.count())
184          loop.exec();
185
186      QCOMPARE(stateCounter.count(), 12);
187      stateCounter.clear();
188      errorCounter.clear();
189
190      as->process(inData, "mech1");
191      if(!errorCounter.count())
192          loop.exec();
193
194      QCOMPARE(stateCounter.count(), 12);
195      stateCounter.clear();
196      errorCounter.clear();
197
198      QCOMPARE(spy.count(), 4);
199
200      QVERIFY(g_processReplyRealmsList.at(0) == "testRealm_after_test");
201      QVERIFY(g_processReplyRealmsList.at(1) == "testRealm_after_test");
202      QVERIFY(g_processReplyRealmsList.at(2) == "testRealm_after_test");
203      QVERIFY(g_processReplyRealmsList.at(3) == "testRealm_after_test");
204  }
205
206  void TestAuthSession::process_with_existing_identity()
207  {
208      AuthSession *as;
209      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
210
211      g_processReplyRealmsList.clear();
212      connect(as, SIGNAL(response(const SignOn::SessionData &)), this, SLOT(response(const SignOn::SessionData &)));
213
214      QSignalSpy errorCounter(as, SIGNAL(error(const SignOn::Error &)));
215      QSignalSpy stateCounter(as, SIGNAL(stateChanged(AuthSession::AuthSessionState, const QString&)));
216      QSignalSpy spy(as, SIGNAL(response(const SignOn::SessionData&)));
217      QEventLoop loop;
218
219      QObject::connect(as, SIGNAL(response(const SignOn::SessionData&)), &loop, SLOT(quit()));
220      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
221      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
222
223      SessionData inData;
224
225      inData.setSecret("testSecret");
226      inData.setUserName("testUsername");
227
228      as->process(inData, "mech1");
229      if(!errorCounter.count())
230          loop.exec();
231      QCOMPARE(stateCounter.count(), 12);
232      stateCounter.clear();
233      errorCounter.clear();
234
235      as->process(inData, "mech1");
236      if(!errorCounter.count())
237          loop.exec();
238      QCOMPARE(stateCounter.count(), 12);
239      stateCounter.clear();
240      errorCounter.clear();
241
242      as->process(inData, "mech1");
243      if(!errorCounter.count())
244          loop.exec();
245      QCOMPARE(stateCounter.count(), 12);
246      stateCounter.clear();
247      errorCounter.clear();
248
249      as->process(inData, "mech1");
250      if(!errorCounter.count())
251          loop.exec();
252      QCOMPARE(stateCounter.count(), 12);
253      stateCounter.clear();
254      errorCounter.clear();
255
256      QCOMPARE(spy.count(), 4);
257
258      QVERIFY(g_processReplyRealmsList.at(0) == "testRealm_after_test");
259      QVERIFY(g_processReplyRealmsList.at(1) == "testRealm_after_test");
260      QVERIFY(g_processReplyRealmsList.at(2) == "testRealm_after_test");
261      QVERIFY(g_processReplyRealmsList.at(3) == "testRealm_after_test");
262
263  }
264
265  void TestAuthSession::process_with_nonexisting_type()
266  {
267      AuthSession *as;
268      SSO_TEST_CREATE_AUTH_SESSION(as, "nonexisting");
269
270      QSignalSpy spyResponse(as, SIGNAL(response(const SignOn::SessionData &)));
271      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
272      QSignalSpy stateCounter(as, SIGNAL(stateChanged(AuthSession::AuthSessionState, const QString&)));
273      QEventLoop loop;
274
275      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()),  Qt::QueuedConnection);
276      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
277
278      SessionData inData;
279
280      inData.setSecret("testSecret");
281      inData.setUserName("testUsername");
282
283      as->process(inData, "mech1");
284      loop.exec();
285
286      as->process(inData, "mech1");
287      loop.exec();
288
289      as->process(inData, "mech1");
290      loop.exec();
291
292      as->process(inData, "mech1");
293      loop.exec();
294
295      QCOMPARE(spyResponse.count(), 0);
296      QVERIFY(spyError.count() > 0);
297      QCOMPARE(stateCounter.count(), 0);
298  }
299
300
301  void TestAuthSession::process_with_nonexisting_method()
302  {
303      AuthSession *as;
304      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
305
306      QSignalSpy spyResponse(as, SIGNAL(response(const SignOn::SessionData&)));
307      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
308      QSignalSpy stateCounter(as, SIGNAL(stateChanged(AuthSession::AuthSessionState, const QString&)));
309      QEventLoop loop;
310
311      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()),  Qt::QueuedConnection);
312      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
313
314      SessionData inData;
315
316      inData.setSecret("testSecret");
317      inData.setUserName("testUsername");
318
319      as->process(inData, "nonexisting");
320      loop.exec();
321
322      as->process(inData, "nonexisting");
323      loop.exec();
324
325      as->process(inData, "nonexisting");
326      loop.exec();
327
328      as->process(inData, "nonexisting");
329      loop.exec();
330
331      QCOMPARE(spyResponse.count(), 0);
332      QCOMPARE(spyError.count(), 4);
333      QCOMPARE(stateCounter.count(), 8);
334  }
335
336
337  void TestAuthSession::process_many_times_after_auth()
338  {
339      AuthSession *as;
340      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
341
342      QSignalSpy spyResponse(as, SIGNAL(response(const SignOn::SessionData&)));
343      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
344      QEventLoop loop;
345
346      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
347      QObject::connect(as, SIGNAL(response(const SignOn::SessionData&)), &loop, SLOT(quit()));
348      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
349
350      SessionData inData;
351
352      inData.setSecret("testSecret");
353      inData.setUserName("testUsername");
354
355      as->process(inData, "mech1");
356      loop.exec();
357      QCOMPARE(spyResponse.count(), 1);
358
359      as->process(inData, "mech1");
360      as->process(inData, "mech1");
361      as->process(inData, "mech1");
362      as->process(inData, "mech1");
363
364      loop.exec();
365
366      QCOMPARE(spyResponse.count(), 2);
367      QCOMPARE(spyError.count(), 3);
368
369      as->process(inData, "mech1");
370      as->process(inData, "mech1");
371      as->process(inData, "mech1");
372      as->process(inData, "mech1");
373
374      loop.exec();
375
376      QCOMPARE(spyResponse.count(), 3);
377      QCOMPARE(spyError.count(), 6);
378
379      as->process(inData, "mech1");
380      as->process(inData, "mech1");
381      as->process(inData, "mech1");
382      as->process(inData, "mech1");
383
384      loop.exec();
385
386      QCOMPARE(spyResponse.count(), 4);
387      QCOMPARE(spyError.count(), 9);
388  }
389
390  void TestAuthSession::process_many_times_before_auth()
391  {
392      AuthSession *as;
393      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
394
395      QSignalSpy spyResponse(as, SIGNAL(response(const SignOn::SessionData&)));
396      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
397      QEventLoop loop;
398
399      QObject::connect(as, SIGNAL(response(const SignOn::SessionData&)), &loop, SLOT(quit()));
400      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
401
402      SessionData inData;
403
404      inData.setSecret("testSecret");
405      inData.setUserName("testUsername");
406
407      as->process(inData, "mech1");
408      as->process(inData, "mech1");
409      as->process(inData, "mech1");
410      as->process(inData, "mech1");
411
412      loop.exec();
413
414      QCOMPARE(spyError.count(), 3);
415      QCOMPARE(spyResponse.count(), 1);
416  }
417
418
419  void TestAuthSession::process_with_big_session_data()
420  {
421      QSKIP("This test requires fix", SkipSingle); //TODO once bug Bug#222200 is fixed, this test case can be enabled
422      AuthSession *as;
423      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
424
425      QSignalSpy spyResponse(as, SIGNAL(response(const SignOn::SessionData&)));
426      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
427      QEventLoop loop;
428
429      QObject::connect(as, SIGNAL(response(const SignOn::SessionData&)),
430                       this, SLOT(response(const SignOn::SessionData&)));
431      QObject::connect(as, SIGNAL(response(const SignOn::SessionData&)), &loop, SLOT(quit()));
432      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
433
434      SessionData inData;
435
436      inData.setSecret("testSecret");
437
438      QString bigString;
439      bigString.fill(QChar('A'), g_bigStringSize);
440      inData.setCaption(bigString);
441
442      as->process(inData, "BLOB");
443
444      loop.exec();
445
446      QCOMPARE(spyError.count(), 0);
447      QCOMPARE(spyResponse.count(), 1);
448      QCOMPARE(g_bigStringReplySize, g_bigStringSize);
449  }
450
451  void TestAuthSession::cancel_immidiately()
452  {
453      AuthSession *as;
454      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
455
456      QSignalSpy spyResponse(as, SIGNAL(response(const SignOn::SessionData&)));
457      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
458      QEventLoop loop;
459
460      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
461      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()),  Qt::QueuedConnection);
462      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
463
464      SessionData inData;
465
466      inData.setSecret("testSecret");
467      inData.setUserName("testUsername");
468
469      as->process(inData, "mech1");
470      as->cancel();
471      loop.exec();
472
473      QCOMPARE(spyResponse.count(), 0);
474      QCOMPARE(spyError.count(), 1);
475
476      as->process(inData, "mech1");
477      as->cancel();
478      loop.exec();
479
480      QCOMPARE(spyResponse.count(), 0);
481      QCOMPARE(spyError.count(), 2);
482
483      as->process(inData, "mech1");
484      as->cancel();
485      loop.exec();
486
487      QCOMPARE(spyResponse.count(), 0);
488      QCOMPARE(spyError.count(), 3);
489
490      as->process(inData, "mech1");
491      as->cancel();
492      loop.exec();
493
494      QCOMPARE(spyResponse.count(), 0);
495      QCOMPARE(spyError.count(), 4);
496  }
497
498  void TestAuthSession::cancel_with_delay()
499  {
500      AuthSession *as;
501      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
502      g_currentSession = as;
503
504      QSignalSpy spyResponse(as, SIGNAL(response(const SignOn::SessionData&)));
505      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
506      QEventLoop loop;
507
508      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
509      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()),  Qt::DirectConnection);
510      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
511
512      SessionData inData;
513
514      inData.setSecret("testSecret");
515      inData.setUserName("testUsername");
516
517      as->process(inData, "mech1");
518      QTimer::singleShot(0.1*1000, this, SLOT(cancel()));
519      loop.exec();
520
521      QCOMPARE(spyResponse.count(), 0);
522      QCOMPARE(spyError.count(), 1);
523
524      as->process(inData, "mech1");
525      QTimer::singleShot(0.1*1000, this, SLOT(cancel()));
526      loop.exec();
527
528      QCOMPARE(spyResponse.count(), 0);
529      QCOMPARE(spyError.count(), 2);
530
531      as->process(inData, "mech1");
532      QTimer::singleShot(0.1*1000, this, SLOT(cancel()));
533      loop.exec();
534
535      QCOMPARE(spyResponse.count(), 0);
536      QCOMPARE(spyError.count(), 3);
537
538      as->process(inData, "mech1");
539      QTimer::singleShot(0.1*1000, this, SLOT(cancel()));
540      loop.exec();
541
542      QCOMPARE(spyResponse.count(), 0);
543      QCOMPARE(spyError.count(), 4);
544  }
545
546  void TestAuthSession::cancel_without_process()
547  {
548      AuthSession *as;
549      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
550      g_currentSession = as;
551
552      QSignalSpy spyError(as, SIGNAL(error(const SignOn::Error &)));
553      QEventLoop loop;
554
555      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()),  Qt::QueuedConnection);
556      QTimer::singleShot(10*1000, &loop, SLOT(quit()));
557
558      QTimer::singleShot(1*1000, &loop, SLOT(quit()));
559      as->cancel();
560      loop.exec();
561
562      QCOMPARE(spyError.count(), 0);
563
564      QTimer::singleShot(1*1000, &loop, SLOT(quit()));
565      QTimer::singleShot(0.1*1000, this, SLOT(cancel()));
566      loop.exec();
567
568      QCOMPARE(spyError.count(), 0);
569
570      QTimer::singleShot(0.1*1000, this, SLOT(cancel()));
571      QTimer::singleShot(1*1000, &loop, SLOT(quit()));
572      loop.exec();
573
574      QCOMPARE(spyError.count(), 0);
575
576      SessionData inData;
577
578      inData.setSecret("testSecret");
579      inData.setUserName("testUsername");
580
581      as->process(inData, "mech1");
582      as->cancel();
583      as->cancel();
584      as->cancel();
585      loop.exec();
586
587      QCOMPARE(spyError.count(), 1);
588  }
589
590  void TestAuthSession::handle_destroyed_signal()
591  {
592      QSKIP("testing in sb", SkipSingle);
593      AuthSession *as;
594      SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest");
595      g_currentSession = as;
596
597      QSignalSpy spy(as, SIGNAL(mechanismsAvailable(const QStringList&)));
598      QSignalSpy errorCounter(as, SIGNAL(error(const SignOn::Error &)));
599      QEventLoop loop;
600
601      QObject::connect(as, SIGNAL(mechanismsAvailable(const QStringList&)), &loop, SLOT(quit()));
602      QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
603
604      /*
605       * 5 minutes + 10 seconds
606       * */
607      QTimer::singleShot(5 * 62 *1000, &loop, SLOT(quit()));
608      loop.exec();
609
610      AuthSession *as2;
611      SSO_TEST_CREATE_AUTH_SESSION(as2, "ssotest");
612
613      QTimer::singleShot(5 * 1000, &loop, SLOT(quit()));
614      loop.exec();
615
616      QStringList wantedMechs;
617      as->queryAvailableMechanisms(wantedMechs);
618
619      if(!errorCounter.count())
620          loop.exec();
621
622      QCOMPARE(spy.count(), 1);
623      QStringList result = spy.at(0).at(0).toStringList();
624      QCOMPARE(result.size(), 4);
625  }
626
627  void TestAuthSession::multi_thread_test()
628  {
629      //execute a SignOn call in a separate thread
630      TestThread thread;
631      thread.start();
632      thread.wait(g_testThreadTimeout + 1000);
633
634      //do the same in this thread - this test succeeds if the
635      //following succeeds
636      process_with_new_identity();
637  }
638
639  void TestAuthSession::cancel()
640  {
641      g_currentSession->cancel();
642  }
643
644  void TestAuthSession::response(const SignOn::SessionData &data)
645  {
646      g_processReplyRealmsList << data.Realm();
647      g_bigStringReplySize = data.Caption().size();
648  }
649
650
651  #ifdef SSOUI_TESTS_ENABLED
652
653   void TestAuthSession::processUi_with_existing_identity()
654   {
655        AuthSession *as;
656        SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest2");
657
658        QSignalSpy errorCounter(as, SIGNAL(error(const SignOn::Error &)));
659        QSignalSpy stateCounter(as, SIGNAL(stateChanged(AuthSession::AuthSessionState, const QString&)));
660        QSignalSpy spy(as, SIGNAL(response(const SessionData&)));
661        QEventLoop loop;
662
663        QObject::connect(as, SIGNAL(response(const SessionData&)), &loop, SLOT(quit()));
664        QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
665        QTimer::singleShot(500*1000, &loop, SLOT(quit()));
666
667        /*
668         * chain of UiSessionData
669         * */
670        QStringList chainOfStates;
671
672        SsoTest2PluginNS::SsoTest2Data testData;
673
674        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
675        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
676        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
677        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
678
679        testData.setChainOfStates(chainOfStates);
680        testData.setCurrentState(0);
681
682        as->process(testData, "mech1");
683
684        if(!errorCounter.count())
685            loop.exec();
686
687        QCOMPARE(spy.count(), 1);
688        if(errorCounter.count())
689            TRACE() << errorCounter.at(0).at(1).toString();
690
691        QCOMPARE(errorCounter.count(), 0);
692
693
694        SignOn::SessionData outData = qVariantValue<SignOn::SessionData>(spy.at(0).at(0));
695        SsoTest2PluginNS::SsoTest2Data resultData = outData.data<SsoTest2PluginNS::SsoTest2Data>();
696
697        foreach(QString result, resultData.ChainOfResults())
698            QCOMPARE(result, QString("OK"));
699    }
700
701   void TestAuthSession::processUi_and_cancel()
702   {
703        AuthSession *as;
704        SSO_TEST_CREATE_AUTH_SESSION(as, "ssotest2");
705        g_currentSession = as;
706
707        QSignalSpy errorCounter(as, SIGNAL(error(const SignOn::Error &)));
708        QSignalSpy stateCounter(as, SIGNAL(stateChanged(AuthSession::AuthSessionState, const QString&)));
709        QSignalSpy spy(as, SIGNAL(response(const SessionData&)));
710        QEventLoop loop;
711
712        QObject::connect(as, SIGNAL(response(const SessionData&)), &loop, SLOT(quit()));
713        QObject::connect(as, SIGNAL(error(const SignOn::Error &)), &loop, SLOT(quit()));
714        QTimer::singleShot(500*1000, &loop, SLOT(quit()));
715
716        /*
717         * chain of UiSessionData
718         * */
719        QStringList chainOfStates;
720
721        SsoTest2PluginNS::SsoTest2Data testData;
722
723        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
724        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
725        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
726        chainOfStates << "Browser" <<"Login" << "Captcha" << "LoginAndCaptcha";
727
728        testData.setChainOfStates(chainOfStates);
729        testData.setCurrentState(0);
730
731        as->process(testData, "mech1");
732        QTimer::singleShot(3*1000, this, SLOT(cancel()));
733
734        if(!errorCounter.count())
735            loop.exec();
736
737        QCOMPARE(spy.count(), 0);
738        QCOMPARE(errorCounter.count(), 1);
739    }
740
741  #endif
742
743  #if !defined(SSO_CI_TESTMANAGEMENT) && !defined(SSOTESTCLIENT_USES_AUTHSESSION)
744       QTEST_MAIN(TestAuthSession)
745  #endif
746
747  #endif //TESTAUTHSESSION_CPP_