source/tests/xestiaab_carddav.cpp

   1 // xestiaab_carddav.h - Xestia Address Book CardDAV Object Unit Tests.
   2 //
   3 // (c) 2012-2015 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Address Book.
   6 //
   7 // Xestia Address Book is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Address Book is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Address Book. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include <gtest/gtest.h>
  20 #include "classes/FakeConnectionObject.h"
  21
  22 // TODO: Add tests for the CardDAV object.
  23
  24 TEST(CardDAV, Use_Fake_To_Setup_And_Check_Connection_Settings_With_TestMode_True){
  25
  26         std::string ServerAddress1 = "gibberish.invalid";
  27         std::string ServerUser1 = "user";
  28         std::string ServerPass1 = "pass";
  29
  30         std::string ServerAddress2 = "gibberish2.invalid";
  31         std::string ServerUser2 = "user2";
  32         std::string ServerPass2 = "pass2";
  33
  34         std::string ServerAddress3 = "gibberish3.invalid";
  35         std::string ServerUser3 = "user3";
  36         std::string ServerPass3 = "pass3";
  37
  38         FakeConnectionObject FakeConnection1(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
  39         FakeConnectionObject FakeConnection2(ServerAddress2, 8800, ServerUser2, ServerPass2, true);
  40         FakeConnectionObject FakeConnection3(ServerAddress3, 8008, ServerUser3, ServerPass3, false);
  41
  42         EXPECT_EQ("gibberish.invalid", FakeConnection1.GetServerAddress());
  43         EXPECT_EQ(8080, FakeConnection1.GetServerPort());
  44         EXPECT_EQ("user", FakeConnection1.GetServerUser());
  45         EXPECT_EQ("pass", FakeConnection1.GetServerPass());
  46         EXPECT_EQ(true, FakeConnection1.GetServerSSL());
  47         EXPECT_EQ(true, FakeConnection1.GetTestMode());
  48
  49         EXPECT_EQ("gibberish2.invalid", FakeConnection2.GetServerAddress());
  50         EXPECT_EQ(8800, FakeConnection2.GetServerPort());
  51         EXPECT_EQ("user2", FakeConnection2.GetServerUser());
  52         EXPECT_EQ("pass2", FakeConnection2.GetServerPass());
  53         EXPECT_EQ(true, FakeConnection2.GetServerSSL());
  54         EXPECT_EQ(true, FakeConnection2.GetTestMode());
  55
  56         EXPECT_EQ("gibberish3.invalid", FakeConnection3.GetServerAddress());
  57         EXPECT_EQ(8008, FakeConnection3.GetServerPort());
  58         EXPECT_EQ("user3", FakeConnection3.GetServerUser());
  59         EXPECT_EQ("pass3", FakeConnection3.GetServerPass());
  60         EXPECT_EQ(false, FakeConnection3.GetServerSSL());
  61         EXPECT_EQ(true, FakeConnection3.GetTestMode());
  62
  63 }
  64
  65 TEST(CardDAV, Use_Fake_To_Setup_And_Check_Connection_Settings_With_TestMode_False){
  66
  67         std::string ServerAddress1 = "gibberish.invalid";
  68         std::string ServerUser1 = "user";
  69         std::string ServerPass1 = "pass";
  70         std::string ServerPrefix1 = "/prefix";
  71         std::string ServerAccount1 = "Account1";
  72
  73         std::string ServerAddress2 = "gibberish2.invalid";
  74         std::string ServerUser2 = "user2";
  75         std::string ServerPass2 = "pass2";
  76         std::string ServerPrefix2 = "/prefix2";
  77         std::string ServerAccount2 = "Account2";
  78
  79         std::string ServerAddress3 = "gibberish3.invalid";
  80         std::string ServerUser3 = "user3";
  81         std::string ServerPass3 = "pass3";
  82         std::string ServerPrefix3 = "/prefix3";
  83         std::string ServerAccount3 = "Account3";
  84
  85         FakeConnectionObject FakeConnection1(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
  86         FakeConnectionObject FakeConnection2(ServerAddress2, 8800, ServerUser2, ServerPass2, true, "/prefix2", "Account2");
  87         FakeConnectionObject FakeConnection3(ServerAddress3, 8008, ServerUser3, ServerPass3, false, "/prefix3", "Account3");
  88
  89         EXPECT_EQ("gibberish.invalid", FakeConnection1.GetServerAddress());
  90         EXPECT_EQ(8080, FakeConnection1.GetServerPort());
  91         EXPECT_EQ("user", FakeConnection1.GetServerUser());
  92         EXPECT_EQ("pass", FakeConnection1.GetServerPass());
  93         EXPECT_EQ(true, FakeConnection1.GetServerSSL());
  94         EXPECT_EQ(false, FakeConnection1.GetTestMode());
  95         EXPECT_EQ("/prefix", FakeConnection1.GetServerPrefix());
  96         EXPECT_EQ("Account1", FakeConnection1.GetServerAccount());
  97
  98         EXPECT_EQ("gibberish2.invalid", FakeConnection2.GetServerAddress());
  99         EXPECT_EQ(8800, FakeConnection2.GetServerPort());
 100         EXPECT_EQ("user2", FakeConnection2.GetServerUser());
 101         EXPECT_EQ("pass2", FakeConnection2.GetServerPass());
 102         EXPECT_EQ(true, FakeConnection2.GetServerSSL());
 103         EXPECT_EQ(false, FakeConnection2.GetTestMode());
 104         EXPECT_EQ("/prefix2", FakeConnection2.GetServerPrefix());
 105         EXPECT_EQ("Account2", FakeConnection2.GetServerAccount());
 106
 107         EXPECT_EQ("gibberish3.invalid", FakeConnection3.GetServerAddress());
 108         EXPECT_EQ(8008, FakeConnection3.GetServerPort());
 109         EXPECT_EQ("user3", FakeConnection3.GetServerUser());
 110         EXPECT_EQ("pass3", FakeConnection3.GetServerPass());
 111         EXPECT_EQ(false, FakeConnection3.GetServerSSL());
 112         EXPECT_EQ(false, FakeConnection3.GetTestMode());
 113         EXPECT_EQ("/prefix3", FakeConnection3.GetServerPrefix());
 114         EXPECT_EQ("Account3", FakeConnection3.GetServerAccount());
 115
 116 }
 117
 118 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_Returning_Success){
 119
 120         std::string ServerAddress1 = "gibberish.invalid";
 121         std::string ServerUser1 = "user";
 122         std::string ServerPass1 = "pass";
 123
 124         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 125         FakeConnection.ResultStatus = COCONNECT_OK;
 126
 127         EXPECT_EQ(COCONNECT_OK, FakeConnection.Connect());
 128
 129 }
 130
 131 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_Returning_InvalidAddress){
 132
 133         std::string ServerAddress1 = "gibberish.invalid";
 134         std::string ServerUser1 = "user";
 135         std::string ServerPass1 = "pass";
 136
 137         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 138         FakeConnection.ResultStatus = COCONNECT_INVALID;
 139
 140         EXPECT_EQ(COCONNECT_INVALID, FakeConnection.Connect());
 141
 142 }
 143
 144 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_Returning_Timeout){
 145
 146         std::string ServerAddress1 = "gibberish.invalid";
 147         std::string ServerUser1 = "user";
 148         std::string ServerPass1 = "pass";
 149
 150         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 151         FakeConnection.ResultStatus = COCONNECT_TIMEOUT;
 152
 153         EXPECT_EQ(COCONNECT_TIMEOUT, FakeConnection.Connect());
 154
 155 }
 156
 157 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_Returning_Authentication_Failure){
 158
 159         std::string ServerAddress1 = "gibberish.invalid";
 160         std::string ServerUser1 = "user";
 161         std::string ServerPass1 = "pass";
 162
 163         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 164         FakeConnection.ResultStatus = COCONNECT_AUTHFAIL;
 165
 166         EXPECT_EQ(COCONNECT_AUTHFAIL, FakeConnection.Connect());
 167
 168 }
 169
 170 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Is_Able_To_Login){
 171
 172         std::string ServerAddress1 = "gibberish.invalid";
 173         std::string ServerUser1 = "user";
 174         std::string ServerPass1 = "pass";
 175
 176         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 177         FakeConnection.ResultAuthPassed = true;
 178         FakeConnection.Connect();
 179
 180         EXPECT_EQ(true, FakeConnection.AbleToLogin());
 181
 182 }
 183
 184 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Is_Unable_To_Login){
 185
 186         std::string ServerAddress1 = "gibberish.invalid";
 187         std::string ServerUser1 = "user";
 188         std::string ServerPass1 = "pass";
 189
 190         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 191         FakeConnection.ResultAuthPassed = false;
 192         FakeConnection.Connect();
 193
 194         EXPECT_EQ(false, FakeConnection.AbleToLogin());
 195
 196 }
 197
 198 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Can_Do_Processing){
 199
 200         std::string ServerAddress1 = "gibberish.invalid";
 201         std::string ServerUser1 = "user";
 202         std::string ServerPass1 = "pass";
 203
 204         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 205         FakeConnection.ResultCanProcess = true;
 206         FakeConnection.Connect();
 207
 208         EXPECT_EQ(true, FakeConnection.CanDoProcessing());
 209
 210 }
 211
 212 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Supports_SSL){
 213
 214         std::string ServerAddress1 = "gibberish.invalid";
 215         std::string ServerUser1 = "user";
 216         std::string ServerPass1 = "pass";
 217
 218         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 219         FakeConnection.ResultSSLStatus  = true;
 220         FakeConnection.Connect();
 221
 222         EXPECT_EQ(true, FakeConnection.CanDoSSL());
 223
 224 }
 225
 226 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Does_Not_Support_SSL){
 227
 228         std::string ServerAddress1 = "gibberish.invalid";
 229         std::string ServerUser1 = "user";
 230         std::string ServerPass1 = "pass";
 231
 232         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 233         FakeConnection.ResultSSLStatus  = false;
 234         FakeConnection.Connect();
 235
 236         EXPECT_EQ(false, FakeConnection.CanDoSSL());
 237
 238 }
 239
 240 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Has_Valid_SSL_Certificate_Data){
 241
 242         std::string ServerAddress1 = "gibberish.invalid";
 243         std::string ServerUser1 = "user";
 244         std::string ServerPass1 = "pass";
 245
 246         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 247         FakeConnection.ResultSSLVerified = true;
 248         FakeConnection.Connect();
 249
 250         EXPECT_EQ(true, FakeConnection.SSLVerify());
 251
 252 }
 253
 254 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Has_Invalid_SSL_Certificate_Data){
 255
 256         std::string ServerAddress1 = "gibberish.invalid";
 257         std::string ServerUser1 = "user";
 258         std::string ServerPass1 = "pass";
 259
 260         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 261         FakeConnection.ResultSSLVerified = false;
 262         FakeConnection.Connect();
 263
 264         EXPECT_EQ(false, FakeConnection.SSLVerify());
 265
 266 }
 267
 268 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Has_A_Valid_Response){
 269
 270         std::string ServerAddress1 = "gibberish.invalid";
 271         std::string ServerUser1 = "user";
 272         std::string ServerPass1 = "pass";
 273
 274         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 275         FakeConnection.ResultValidResponse = true;
 276         FakeConnection.Connect();
 277
 278         EXPECT_EQ(true, FakeConnection.HasValidResponse());
 279
 280 }
 281
 282 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Has_A_Invalid_Response){
 283
 284         std::string ServerAddress1 = "gibberish.invalid";
 285         std::string ServerUser1 = "user";
 286         std::string ServerPass1 = "pass";
 287
 288         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 289         FakeConnection.ResultValidResponse = false;
 290         FakeConnection.Connect();
 291
 292         EXPECT_EQ(false, FakeConnection.HasValidResponse());
 293
 294 }
 295
 296 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Uses_A_Self_Signed_SSL_Certificate){
 297
 298         std::string ServerAddress1 = "gibberish.invalid";
 299         std::string ServerUser1 = "user";
 300         std::string ServerPass1 = "pass";
 301
 302         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 303         FakeConnection.ResultSelfSigned = true;
 304         FakeConnection.Connect();
 305
 306         EXPECT_EQ(true, FakeConnection.IsSelfSigned());
 307
 308 }
 309
 310 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Doesnt_Use_A_Self_Signed_SSL_Certificate){
 311
 312         std::string ServerAddress1 = "gibberish.invalid";
 313         std::string ServerUser1 = "user";
 314         std::string ServerPass1 = "pass";
 315
 316         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 317         FakeConnection.ResultSelfSigned = false;
 318         FakeConnection.Connect();
 319
 320         EXPECT_EQ(false, FakeConnection.IsSelfSigned());
 321
 322 }
 323
 324 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Gets_The_Server_Prefix_Of_Prefix_Test_A){
 325
 326         std::string ServerAddress1 = "gibberish.invalid";
 327         std::string ServerUser1 = "user";
 328         std::string ServerPass1 = "pass";
 329
 330         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 331         FakeConnection.ResultServerPrefix = "/prefix/test/a";
 332         FakeConnection.Connect();
 333
 334         EXPECT_EQ("/prefix/test/a", FakeConnection.GetDefaultPrefix());
 335
 336 }
 337
 338 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Gets_The_Server_Prefix_Of_Prefix_Test_B){
 339
 340         std::string ServerAddress1 = "gibberish.invalid";
 341         std::string ServerUser1 = "user";
 342         std::string ServerPass1 = "pass";
 343
 344         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true);
 345         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 346         FakeConnection.Connect();
 347
 348         EXPECT_EQ("/prefix/test/b", FakeConnection.GetDefaultPrefix());
 349
 350 }
 351
 352 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Adds_A_Contact_Successfully){
 353
 354         std::string ServerAddress1 = "gibberish.invalid";
 355         std::string ServerUser1 = "user";
 356         std::string ServerPass1 = "pass";
 357
 358         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 359         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 360         FakeConnection.Connect();
 361
 362         std::string ContactFile =
 363         "BEGIN:VCARD\n"
 364         "VERSION:4.0\n"
 365         "UID:84q2ioj13jofiujqwr\n"
 366         "N:;;Meep;Moop;;\n"
 367         "FN:The Meep Moop\n"
 368         "END:VCARD";
 369
 370         FakeConnection.TestRequestResult = COREQUEST_OK;
 371         FakeConnection.TestEntityTag = "4324svafhuiaffsdhui";
 372         FakeConnection.TestResultCode = 201;
 373         FakeConnection.TestSessionCode = 0;
 374         FakeConnection.TestResultMessage = "";
 375
 376         COServerResponse AddContactResult = FakeConnection.AddContact("testfile.vcf", ContactFile);
 377
 378         EXPECT_EQ(COREQUEST_OK, AddContactResult.RequestResult);
 379         EXPECT_EQ("4324svafhuiaffsdhui", AddContactResult.EntityTag);
 380         EXPECT_EQ(201, AddContactResult.ResultCode);
 381         EXPECT_EQ(0, AddContactResult.SessionCode);
 382         EXPECT_EQ("", AddContactResult.ResultMessage);
 383
 384 }
 385
 386 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Add_A_Contact_Due_To_Permissions){
 387
 388         std::string ServerAddress1 = "gibberish.invalid";
 389         std::string ServerUser1 = "user";
 390         std::string ServerPass1 = "pass";
 391
 392         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 393         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 394         FakeConnection.Connect();
 395
 396         std::string ContactFile =
 397         "BEGIN:VCARD\n"
 398         "VERSION:4.0\n"
 399         "UID:84q2ioj13jofiujqwr\n"
 400         "N:;;Meep;Moop;;\n"
 401         "FN:The Meep Moop\n"
 402         "END:VCARD";
 403
 404         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 405         FakeConnection.TestEntityTag = "";
 406         FakeConnection.TestResultCode = 403;
 407         FakeConnection.TestSessionCode = 22;
 408         FakeConnection.TestResultMessage = "You do not have permission to add this resource.";
 409
 410         COServerResponse AddContactResult = FakeConnection.AddContact("testfile.vcf", ContactFile);
 411
 412         EXPECT_EQ(COREQUEST_ERROR_SERVER, AddContactResult.RequestResult);
 413         EXPECT_EQ("", AddContactResult.EntityTag);
 414         EXPECT_EQ(403, AddContactResult.ResultCode);
 415         EXPECT_EQ(22, AddContactResult.SessionCode);
 416         EXPECT_EQ("You do not have permission to add this resource.", AddContactResult.ResultMessage);
 417
 418 }
 419
 420 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Add_A_Contact_Due_To_Invalid_Path){
 421
 422         std::string ServerAddress1 = "gibberish.invalid";
 423         std::string ServerUser1 = "user";
 424         std::string ServerPass1 = "pass";
 425
 426         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 427         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 428         FakeConnection.Connect();
 429
 430         std::string ContactFile =
 431         "BEGIN:VCARD\n"
 432         "VERSION:4.0\n"
 433         "UID:84q2ioj13jofiujqwr\n"
 434         "N:;;Meep;Moop;;\n"
 435         "FN:The Meep Moop\n"
 436         "END:VCARD";
 437
 438         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 439         FakeConnection.TestEntityTag = "";
 440         FakeConnection.TestResultCode = 404;
 441         FakeConnection.TestSessionCode = 22;
 442         FakeConnection.TestResultMessage = "The location cannot be found.";
 443
 444         COServerResponse AddContactResult = FakeConnection.AddContact("testfile.vcf", ContactFile);
 445
 446         EXPECT_EQ(COREQUEST_ERROR_SERVER, AddContactResult.RequestResult);
 447         EXPECT_EQ("", AddContactResult.EntityTag);
 448         EXPECT_EQ(404, AddContactResult.ResultCode);
 449         EXPECT_EQ(22, AddContactResult.SessionCode);
 450         EXPECT_EQ("The location cannot be found.", AddContactResult.ResultMessage);
 451
 452 }
 453
 454 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Add_A_Contact_Due_To_No_Connection){
 455
 456         std::string ServerAddress1 = "gibberish.invalid";
 457         std::string ServerUser1 = "user";
 458         std::string ServerPass1 = "pass";
 459
 460         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 461         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 462         FakeConnection.Connect();
 463
 464         std::string ContactFile =
 465         "BEGIN:VCARD\n"
 466         "VERSION:4.0\n"
 467         "UID:84q2ioj13jofiujqwr\n"
 468         "N:;;Meep;Moop;;\n"
 469         "FN:The Meep Moop\n"
 470         "END:VCARD";
 471
 472         FakeConnection.TestRequestResult = COREQUEST_ERROR_NOTCONNECTED;
 473         FakeConnection.TestEntityTag = "";
 474         FakeConnection.TestResultCode = 0;
 475         FakeConnection.TestSessionCode = 0;
 476         FakeConnection.TestResultMessage = "";
 477
 478         COServerResponse AddContactResult = FakeConnection.AddContact("testfile.vcf", ContactFile);
 479
 480         EXPECT_EQ(COREQUEST_ERROR_NOTCONNECTED, AddContactResult.RequestResult);
 481         EXPECT_EQ("", AddContactResult.EntityTag);
 482         EXPECT_EQ(0, AddContactResult.ResultCode);
 483         EXPECT_EQ(0, AddContactResult.SessionCode);
 484         EXPECT_EQ("", AddContactResult.ResultMessage);
 485
 486 }
 487
 488 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Edits_A_Server_Contact){
 489
 490         std::string ServerAddress1 = "gibberish.invalid";
 491         std::string ServerUser1 = "user";
 492         std::string ServerPass1 = "pass";
 493
 494         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 495         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 496         FakeConnection.Connect();
 497
 498         std::string ContactFile =
 499         "BEGIN:VCARD\n"
 500         "VERSION:4.0\n"
 501         "UID:84q2ioj13jofiujqwrAAA\n"
 502         "N:;;Meep;Moop;;\n"
 503         "FN:The Meep Moop\n"
 504         "END:VCARD";
 505
 506         FakeConnection.TestRequestResult = COREQUEST_OK;
 507         FakeConnection.TestEntityTag = "a23124sfadfdvxc1646541bsdfaf";
 508         FakeConnection.TestResultCode = 200;
 509         FakeConnection.TestSessionCode = 0;
 510         FakeConnection.TestResultMessage = "";
 511
 512         COServerResponse EditContactResult = FakeConnection.EditContact("testfile.vcf", ContactFile);
 513
 514         EXPECT_EQ(COREQUEST_OK, EditContactResult.RequestResult);
 515         EXPECT_EQ("a23124sfadfdvxc1646541bsdfaf", EditContactResult.EntityTag);
 516         EXPECT_EQ(200, EditContactResult.ResultCode);
 517         EXPECT_EQ(0, EditContactResult.SessionCode);
 518         EXPECT_EQ("", EditContactResult.ResultMessage);
 519
 520         FakeConnection.TestRequestResult = COREQUEST_OK;
 521         FakeConnection.TestEntityTag = "asf84sa484saf614as64asvada4s6fas";
 522         FakeConnection.TestResultCode = 204;
 523         FakeConnection.TestSessionCode = 0;
 524         FakeConnection.TestResultMessage = "";
 525
 526         EditContactResult = FakeConnection.EditContact("testfile.vcf", ContactFile);
 527
 528         EXPECT_EQ(COREQUEST_OK, EditContactResult.RequestResult);
 529         EXPECT_EQ("asf84sa484saf614as64asvada4s6fas", EditContactResult.EntityTag);
 530         EXPECT_EQ(204, EditContactResult.ResultCode);
 531         EXPECT_EQ(0, EditContactResult.SessionCode);
 532         EXPECT_EQ("", EditContactResult.ResultMessage);
 533
 534 }
 535
 536 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Edit_A_Server_Contact_Due_To_Invalid_Permissions){
 537
 538         std::string ServerAddress1 = "gibberish.invalid";
 539         std::string ServerUser1 = "user";
 540         std::string ServerPass1 = "pass";
 541
 542         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 543         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 544         FakeConnection.Connect();
 545
 546         std::string ContactFile =
 547         "BEGIN:VCARD\n"
 548         "VERSION:4.0\n"
 549         "UID:84q2ioj13jofiujqwrAAA\n"
 550         "N:;;Meep;Moop;;\n"
 551         "FN:The Meep Moop\n"
 552         "END:VCARD";
 553
 554         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 555         FakeConnection.TestEntityTag = "";
 556         FakeConnection.TestResultCode = 403;
 557         FakeConnection.TestSessionCode = 22;
 558         FakeConnection.TestResultMessage = "You do not have permission to add this resource.";
 559
 560         COServerResponse EditContactResult = FakeConnection.EditContact("testfile.vcf", ContactFile);
 561
 562         EXPECT_EQ(COREQUEST_ERROR_SERVER, EditContactResult.RequestResult);
 563         EXPECT_EQ("", EditContactResult.EntityTag);
 564         EXPECT_EQ(403, EditContactResult.ResultCode);
 565         EXPECT_EQ(22, EditContactResult.SessionCode);
 566         EXPECT_EQ("You do not have permission to add this resource.", EditContactResult.ResultMessage);
 567
 568 }
 569
 570 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Edit_A_Server_Contact_Due_To_Invalid_Location){
 571
 572         std::string ServerAddress1 = "gibberish.invalid";
 573         std::string ServerUser1 = "user";
 574         std::string ServerPass1 = "pass";
 575
 576         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 577         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 578         FakeConnection.Connect();
 579
 580         std::string ContactFile =
 581         "BEGIN:VCARD\n"
 582         "VERSION:4.0\n"
 583         "UID:84q2ioj13jofiujqwrAAA\n"
 584         "N:;;Meep;Moop;;\n"
 585         "FN:The Meep Moop\n"
 586         "END:VCARD";
 587
 588         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 589         FakeConnection.TestEntityTag = "";
 590         FakeConnection.TestResultCode = 404;
 591         FakeConnection.TestSessionCode = 22;
 592         FakeConnection.TestResultMessage = "The resource could not be found.";
 593
 594         COServerResponse EditContactResult = FakeConnection.EditContact("testfile.vcf", ContactFile);
 595
 596         EXPECT_EQ(COREQUEST_ERROR_SERVER, EditContactResult.RequestResult);
 597         EXPECT_EQ("", EditContactResult.EntityTag);
 598         EXPECT_EQ(404, EditContactResult.ResultCode);
 599         EXPECT_EQ(22, EditContactResult.SessionCode);
 600         EXPECT_EQ("The resource could not be found.", EditContactResult.ResultMessage);
 601
 602 }
 603
 604 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Edit_A_Server_Contact_Due_To_No_Connection){
 605
 606         std::string ServerAddress1 = "gibberish.invalid";
 607         std::string ServerUser1 = "user";
 608         std::string ServerPass1 = "pass";
 609
 610         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 611         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 612         FakeConnection.Connect();
 613
 614         std::string ContactFile =
 615         "BEGIN:VCARD\n"
 616         "VERSION:4.0\n"
 617         "UID:84q2ioj13jofiujqwrAAA\n"
 618         "N:;;Meep;Moop;;\n"
 619         "FN:The Meep Moop\n"
 620         "END:VCARD";
 621
 622         FakeConnection.TestRequestResult = COREQUEST_ERROR_NOTCONNECTED;
 623         FakeConnection.TestEntityTag = "";
 624         FakeConnection.TestResultCode = 0;
 625         FakeConnection.TestSessionCode = 0;
 626         FakeConnection.TestResultMessage = "";
 627
 628         COServerResponse EditContactResult = FakeConnection.EditContact("testfile.vcf", ContactFile);
 629
 630         EXPECT_EQ(COREQUEST_ERROR_NOTCONNECTED, EditContactResult.RequestResult);
 631         EXPECT_EQ("", EditContactResult.EntityTag);
 632         EXPECT_EQ(0, EditContactResult.ResultCode);
 633         EXPECT_EQ(0, EditContactResult.SessionCode);
 634         EXPECT_EQ("", EditContactResult.ResultMessage);
 635
 636 }
 637
 638 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Deletes_A_Server_Contact){
 639
 640         std::string ServerAddress1 = "gibberish.invalid";
 641         std::string ServerUser1 = "user";
 642         std::string ServerPass1 = "pass";
 643
 644         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 645         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 646         FakeConnection.Connect();
 647
 648         FakeConnection.TestRequestResult = COREQUEST_OK;
 649         FakeConnection.TestEntityTag = "";
 650         FakeConnection.TestResultCode = 200;
 651         FakeConnection.TestSessionCode = 0;
 652         FakeConnection.TestResultMessage = "";
 653
 654         COServerResponse DeleteContactResult = FakeConnection.DeleteContact("testfile.vcf", "a23124sfadfdvxc1646541bsdfaf");
 655
 656         EXPECT_EQ(COREQUEST_OK, DeleteContactResult.RequestResult);
 657         EXPECT_EQ("", DeleteContactResult.EntityTag);
 658         EXPECT_EQ(200, DeleteContactResult.ResultCode);
 659         EXPECT_EQ(0, DeleteContactResult.SessionCode);
 660         EXPECT_EQ("", DeleteContactResult.ResultMessage);
 661
 662         FakeConnection.TestRequestResult = COREQUEST_OK;
 663         FakeConnection.TestEntityTag = "";
 664         FakeConnection.TestResultCode = 204;
 665         FakeConnection.TestSessionCode = 0;
 666         FakeConnection.TestResultMessage = "";
 667
 668         DeleteContactResult = FakeConnection.DeleteContact("testfile.vcf", "asf84sa484saf614as64asvada4s6fas");
 669
 670         EXPECT_EQ(COREQUEST_OK, DeleteContactResult.RequestResult);
 671         EXPECT_EQ("", DeleteContactResult.EntityTag);
 672         EXPECT_EQ(204, DeleteContactResult.ResultCode);
 673         EXPECT_EQ(0, DeleteContactResult.SessionCode);
 674         EXPECT_EQ("", DeleteContactResult.ResultMessage);
 675
 676 }
 677
 678 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Delete_A_Server_Contact_Due_To_Invalid_Permissions){
 679
 680         std::string ServerAddress1 = "gibberish.invalid";
 681         std::string ServerUser1 = "user";
 682         std::string ServerPass1 = "pass";
 683
 684         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 685         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 686         FakeConnection.Connect();
 687
 688         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 689         FakeConnection.TestEntityTag = "";
 690         FakeConnection.TestResultCode = 403;
 691         FakeConnection.TestSessionCode = 22;
 692         FakeConnection.TestResultMessage = "You do not have permission to delete this resource.";
 693
 694         COServerResponse DeleteContactResult = FakeConnection.DeleteContact("testfile.vcf", "a23124sfadfdvxc1646541bsdfaf");
 695
 696         EXPECT_EQ(COREQUEST_ERROR_SERVER, DeleteContactResult.RequestResult);
 697         EXPECT_EQ("", DeleteContactResult.EntityTag);
 698         EXPECT_EQ(403, DeleteContactResult.ResultCode);
 699         EXPECT_EQ(22, DeleteContactResult.SessionCode);
 700         EXPECT_EQ("You do not have permission to delete this resource.", DeleteContactResult.ResultMessage);
 701
 702 }
 703
 704 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Delete_A_Server_Contact_Due_To_Missing_Location){
 705
 706         std::string ServerAddress1 = "gibberish.invalid";
 707         std::string ServerUser1 = "user";
 708         std::string ServerPass1 = "pass";
 709
 710         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 711         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 712         FakeConnection.Connect();
 713
 714         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 715         FakeConnection.TestEntityTag = "";
 716         FakeConnection.TestResultCode = 404;
 717         FakeConnection.TestSessionCode = 22;
 718         FakeConnection.TestResultMessage = "The resource could not be found.";
 719
 720         COServerResponse DeleteContactResult = FakeConnection.DeleteContact("testfile.vcf", "a23124sfadfdvxc1646541bsdfaf");
 721
 722         EXPECT_EQ(COREQUEST_ERROR_SERVER, DeleteContactResult.RequestResult);
 723         EXPECT_EQ("", DeleteContactResult.EntityTag);
 724         EXPECT_EQ(404, DeleteContactResult.ResultCode);
 725         EXPECT_EQ(22, DeleteContactResult.SessionCode);
 726         EXPECT_EQ("The resource could not be found.", DeleteContactResult.ResultMessage);
 727
 728 }
 729
 730 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Delete_A_Server_Contact_Due_To_No_Connection){
 731
 732         std::string ServerAddress1 = "gibberish.invalid";
 733         std::string ServerUser1 = "user";
 734         std::string ServerPass1 = "pass";
 735
 736         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 737         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 738         FakeConnection.Connect();
 739
 740         FakeConnection.TestRequestResult = COREQUEST_ERROR_NOTCONNECTED;
 741         FakeConnection.TestEntityTag = "";
 742         FakeConnection.TestResultCode = 0;
 743         FakeConnection.TestSessionCode = 0;
 744         FakeConnection.TestResultMessage = "";
 745
 746         COServerResponse DeleteContactResult = FakeConnection.DeleteContact("testfile.vcf", "a23124sfadfdvxc1646541bsdfaf");
 747
 748         EXPECT_EQ(COREQUEST_ERROR_NOTCONNECTED, DeleteContactResult.RequestResult);
 749         EXPECT_EQ("", DeleteContactResult.EntityTag);
 750         EXPECT_EQ(0, DeleteContactResult.ResultCode);
 751         EXPECT_EQ(0, DeleteContactResult.SessionCode);
 752         EXPECT_EQ("", DeleteContactResult.ResultMessage);
 753
 754 }
 755
 756 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Gets_Server_Entity_Tag_Value){
 757
 758         std::string ServerAddress1 = "gibberish.invalid";
 759         std::string ServerUser1 = "user";
 760         std::string ServerPass1 = "pass";
 761
 762         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 763         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 764         FakeConnection.Connect();
 765
 766         FakeConnection.TestRequestResult = COREQUEST_OK;
 767         FakeConnection.TestEntityTag = "a23124sfadfdvxc1646541bsdfaf";
 768         FakeConnection.TestResultCode = 200;
 769         FakeConnection.TestSessionCode = 0;
 770         FakeConnection.TestResultMessage = "";
 771
 772         COServerResponse EntityTagResult = FakeConnection.GetServerEntityTagValue("testfile.vcf");
 773
 774         EXPECT_EQ(COREQUEST_OK, EntityTagResult.RequestResult);
 775         EXPECT_EQ("a23124sfadfdvxc1646541bsdfaf", EntityTagResult.EntityTag);
 776         EXPECT_EQ(200, EntityTagResult.ResultCode);
 777         EXPECT_EQ(0, EntityTagResult.SessionCode);
 778         EXPECT_EQ("", EntityTagResult.ResultMessage);
 779
 780 }
 781
 782 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Get_Server_Entity_Tag_Value_Due_To_Invalid_Permissions){
 783
 784         std::string ServerAddress1 = "gibberish.invalid";
 785         std::string ServerUser1 = "user";
 786         std::string ServerPass1 = "pass";
 787
 788         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 789         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 790         FakeConnection.Connect();
 791
 792         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 793         FakeConnection.TestEntityTag = "";
 794         FakeConnection.TestResultCode = 403;
 795         FakeConnection.TestSessionCode = 22;
 796         FakeConnection.TestResultMessage = "You do not have permission to access this resource.";
 797
 798         COServerResponse EntityTagResult = FakeConnection.GetServerEntityTagValue("testfile.vcf");
 799
 800         EXPECT_EQ(COREQUEST_ERROR_SERVER, EntityTagResult.RequestResult);
 801         EXPECT_EQ("", EntityTagResult.EntityTag);
 802         EXPECT_EQ(403, EntityTagResult.ResultCode);
 803         EXPECT_EQ(22, EntityTagResult.SessionCode);
 804         EXPECT_EQ("You do not have permission to access this resource.", EntityTagResult.ResultMessage);
 805
 806 }
 807
 808 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Get_Server_Entity_Tag_Value_Due_To_Missing_Resource){
 809
 810         std::string ServerAddress1 = "gibberish.invalid";
 811         std::string ServerUser1 = "user";
 812         std::string ServerPass1 = "pass";
 813
 814         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 815         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 816         FakeConnection.Connect();
 817
 818         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
 819         FakeConnection.TestEntityTag = "";
 820         FakeConnection.TestResultCode = 404;
 821         FakeConnection.TestSessionCode = 22;
 822         FakeConnection.TestResultMessage = "The resource cannot be found.";
 823
 824         COServerResponse EntityTagResult = FakeConnection.GetServerEntityTagValue("testfile.vcf");
 825
 826         EXPECT_EQ(COREQUEST_ERROR_SERVER, EntityTagResult.RequestResult);
 827         EXPECT_EQ("", EntityTagResult.EntityTag);
 828         EXPECT_EQ(404, EntityTagResult.ResultCode);
 829         EXPECT_EQ(22, EntityTagResult.SessionCode);
 830         EXPECT_EQ("The resource cannot be found.", EntityTagResult.ResultMessage);
 831
 832 }
 833
 834 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Get_Server_Entity_Tag_Value_Due_To_No_Connection){
 835
 836         std::string ServerAddress1 = "gibberish.invalid";
 837         std::string ServerUser1 = "user";
 838         std::string ServerPass1 = "pass";
 839
 840         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 841         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 842         FakeConnection.Connect();
 843
 844         FakeConnection.TestRequestResult = COREQUEST_ERROR_NOTCONNECTED;
 845         FakeConnection.TestEntityTag = "";
 846         FakeConnection.TestResultCode = 0;
 847         FakeConnection.TestSessionCode = 0;
 848         FakeConnection.TestResultMessage = "";
 849
 850         COServerResponse EntityTagResult = FakeConnection.GetServerEntityTagValue("testfile.vcf");
 851
 852         EXPECT_EQ(COREQUEST_ERROR_NOTCONNECTED, EntityTagResult.RequestResult);
 853         EXPECT_EQ("", EntityTagResult.EntityTag);
 854         EXPECT_EQ(0, EntityTagResult.ResultCode);
 855         EXPECT_EQ(0, EntityTagResult.SessionCode);
 856         EXPECT_EQ("", EntityTagResult.ResultMessage);
 857
 858 }
 859
 860 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Gets_Server_Contact_Data){
 861
 862         std::string ServerAddress1 = "gibberish.invalid";
 863         std::string ServerUser1 = "user";
 864         std::string ServerPass1 = "pass";
 865
 866         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 867         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 868         FakeConnection.Connect();
 869
 870         std::string ContactFile =
 871         "BEGIN:VCARD\n"
 872         "VERSION:4.0\n"
 873         "UID:84q2ioj13jofiujqwrAAA\n"
 874         "N:;;Meep;Moop;;\n"
 875         "FN:The Meep Moop\n"
 876         "END:VCARD";
 877
 878         FakeConnection.TestRequestResult = COREQUEST_OK;
 879         FakeConnection.TestEntityTag = "";
 880         FakeConnection.TestResultCode = 200;
 881         FakeConnection.TestSessionCode = 0;
 882         FakeConnection.TestResultMessage = ContactFile;
 883
 884         COServerResponse ServerDataResult = FakeConnection.GetContact("/location/testfile.vcf");
 885
 886         EXPECT_EQ(COREQUEST_OK, ServerDataResult.RequestResult);
 887         EXPECT_EQ("", ServerDataResult.EntityTag);
 888         EXPECT_EQ(200, ServerDataResult.ResultCode);
 889         EXPECT_EQ(0, ServerDataResult.SessionCode);
 890         EXPECT_EQ(ContactFile, ServerDataResult.ResultMessage);
 891
 892 }
 893
 894 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Gets_Server_Contact_Data_Due_To_Invalid_Permissions){
 895
 896         std::string ServerAddress1 = "gibberish.invalid";
 897         std::string ServerUser1 = "user";
 898         std::string ServerPass1 = "pass";
 899
 900         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 901         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 902         FakeConnection.Connect();
 903
 904         FakeConnection.TestRequestResult = COREQUEST_OK;
 905         FakeConnection.TestEntityTag = "";
 906         FakeConnection.TestResultCode = 403;
 907         FakeConnection.TestSessionCode = 22;
 908         FakeConnection.TestResultMessage = "You do not have permission to access this resource.";
 909
 910         COServerResponse ServerDataResult = FakeConnection.GetContact("/location/testfile.vcf");
 911
 912         EXPECT_EQ(COREQUEST_OK, ServerDataResult.RequestResult);
 913         EXPECT_EQ("", ServerDataResult.EntityTag);
 914         EXPECT_EQ(403, ServerDataResult.ResultCode);
 915         EXPECT_EQ(22, ServerDataResult.SessionCode);
 916         EXPECT_EQ("You do not have permission to access this resource.", ServerDataResult.ResultMessage);
 917
 918 }
 919
 920 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Gets_Server_Contact_Data_Due_To_Missing_Resource){
 921
 922         std::string ServerAddress1 = "gibberish.invalid";
 923         std::string ServerUser1 = "user";
 924         std::string ServerPass1 = "pass";
 925
 926         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 927         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 928         FakeConnection.Connect();
 929
 930         FakeConnection.TestRequestResult = COREQUEST_OK;
 931         FakeConnection.TestEntityTag = "";
 932         FakeConnection.TestResultCode = 404;
 933         FakeConnection.TestSessionCode = 22;
 934         FakeConnection.TestResultMessage = "The resource could not be found.";
 935
 936         COServerResponse ServerDataResult = FakeConnection.GetContact("/location/testfile.vcf");
 937
 938         EXPECT_EQ(COREQUEST_OK, ServerDataResult.RequestResult);
 939         EXPECT_EQ("", ServerDataResult.EntityTag);
 940         EXPECT_EQ(404, ServerDataResult.ResultCode);
 941         EXPECT_EQ(22, ServerDataResult.SessionCode);
 942         EXPECT_EQ("The resource could not be found.", ServerDataResult.ResultMessage);
 943
 944 }
 945
 946 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Get_Server_Contact_Data_Due_To_No_Connection){
 947
 948         std::string ServerAddress1 = "gibberish.invalid";
 949         std::string ServerUser1 = "user";
 950         std::string ServerPass1 = "pass";
 951
 952         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 953         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 954         FakeConnection.Connect();
 955
 956         FakeConnection.TestRequestResult = COREQUEST_ERROR_NOTCONNECTED;
 957         FakeConnection.TestEntityTag = "";
 958         FakeConnection.TestResultCode = 0;
 959         FakeConnection.TestSessionCode = 0;
 960         FakeConnection.TestResultMessage = "";
 961
 962         COServerResponse ServerDataResult = FakeConnection.GetContact("/location/testfile.vcf");
 963
 964         EXPECT_EQ(COREQUEST_ERROR_NOTCONNECTED, ServerDataResult.RequestResult);
 965         EXPECT_EQ("", ServerDataResult.EntityTag);
 966         EXPECT_EQ(0, ServerDataResult.ResultCode);
 967         EXPECT_EQ(0, ServerDataResult.SessionCode);
 968         EXPECT_EQ("", ServerDataResult.ResultMessage);
 969
 970 }
 971
 972 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Gets_A_Full_Server_Contact_List){
 973
 974         std::string ServerAddress1 = "gibberish.invalid";
 975         std::string ServerUser1 = "user";
 976         std::string ServerPass1 = "pass";
 977
 978         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
 979         FakeConnection.ResultServerPrefix = "/prefix/test/b";
 980         FakeConnection.Connect();
 981
 982         std::string ContactFile1 =
 983         "BEGIN:VCARD\n"
 984         "VERSION:4.0\n"
 985         "UID:84q2ioj13jofiujqwrAAA-1\n"
 986         "N:;;Meep;Moop;;\n"
 987         "FN:The Meep Moop\n"
 988         "END:VCARD";
 989
 990         std::string ContactFile2 =
 991         "BEGIN:VCARD\n"
 992         "VERSION:4.0\n"
 993         "UID:84q2ioj13jofiujqwrAAA-2\n"
 994         "N:;;Meep;Moop;;\n"
 995         "FN:The Meep Moop\n"
 996         "END:VCARD";
 997
 998         std::string ContactFile3 =
 999         "BEGIN:VCARD\n"
1000         "VERSION:4.0\n"
1001         "UID:84q2ioj13jofiujqwrAAA-3\n"
1002         "N:;;Meep;Moop;;\n"
1003         "FN:The Meep Moop\n"
1004         "END:VCARD";
1005
1006         COContactList ContactListSetup;
1007         COContactData ContactPerson;
1008
1009         ContactPerson.Location = "/location1.vcf";
1010         ContactPerson.Data = ContactFile1;
1011         ContactListSetup.ListData.push_back(ContactPerson);
1012
1013         ContactPerson.Location = "/location2.vcf";
1014         ContactPerson.Data = ContactFile2;
1015         ContactListSetup.ListData.push_back(ContactPerson);
1016
1017         ContactPerson.Location = "/location3.vcf";
1018         ContactPerson.Data = ContactFile3;
1019         ContactListSetup.ListData.push_back(ContactPerson);
1020         ContactListSetup.SyncToken = "2312312-12312312";
1021
1022         FakeConnection.TestContactList = ContactListSetup;
1023         FakeConnection.TestRequestResult = COREQUEST_OK;
1024         FakeConnection.TestEntityTag = "";
1025         FakeConnection.TestResultCode = 200;
1026         FakeConnection.TestSessionCode = 0;
1027         FakeConnection.TestResultMessage = "";
1028
1029         COContactList ServerDataResult = FakeConnection.GetContactList("");
1030
1031         EXPECT_EQ(COREQUEST_OK, ServerDataResult.ServerResponse.RequestResult);
1032         EXPECT_EQ("", ServerDataResult.ServerResponse.EntityTag);
1033         EXPECT_EQ(200, ServerDataResult.ServerResponse.ResultCode);
1034         EXPECT_EQ(0, ServerDataResult.ServerResponse.SessionCode);
1035         EXPECT_EQ("", ServerDataResult.ServerResponse.ResultMessage);
1036
1037         EXPECT_EQ("2312312-12312312", ServerDataResult.SyncToken);
1038
1039         EXPECT_EQ(3, ServerDataResult.ListData.size());
1040
1041         EXPECT_EQ("/location1.vcf", ServerDataResult.ListData[0].Location);
1042         EXPECT_EQ(ContactFile1, ServerDataResult.ListData[0].Data);
1043
1044         EXPECT_EQ("/location2.vcf", ServerDataResult.ListData[1].Location);
1045         EXPECT_EQ(ContactFile2, ServerDataResult.ListData[1].Data);
1046
1047         EXPECT_EQ("/location3.vcf", ServerDataResult.ListData[2].Location);
1048         EXPECT_EQ(ContactFile3, ServerDataResult.ListData[2].Data);
1049
1050 }
1051
1052 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Gets_A_Partial_Server_Contact_List){
1053
1054         std::string ServerAddress1 = "gibberish.invalid";
1055         std::string ServerUser1 = "user";
1056         std::string ServerPass1 = "pass";
1057
1058         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
1059         FakeConnection.ResultServerPrefix = "/prefix/test/b";
1060         FakeConnection.Connect();
1061
1062         std::string ContactFile3 =
1063         "BEGIN:VCARD\n"
1064         "VERSION:4.0\n"
1065         "UID:84q2ioj13jofiujqwrAAA-3\n"
1066         "N:;;Meep;Moop;;\n"
1067         "FN:The Meep Moop\n"
1068         "END:VCARD";
1069
1070         COContactList ContactListSetup;
1071         COContactData ContactPerson;
1072
1073         ContactPerson.Location = "/location3.vcf";
1074         ContactPerson.Data = ContactFile3;
1075         ContactListSetup.ListData.push_back(ContactPerson);
1076         ContactListSetup.SyncToken = "5964589-43543534";
1077
1078         FakeConnection.TestContactList = ContactListSetup;
1079         FakeConnection.TestRequestResult = COREQUEST_OK;
1080         FakeConnection.TestEntityTag = "";
1081         FakeConnection.TestResultCode = 200;
1082         FakeConnection.TestSessionCode = 0;
1083         FakeConnection.TestResultMessage = "";
1084
1085         COContactList ServerDataResult = FakeConnection.GetContactList("2312312-12312312");
1086
1087         EXPECT_EQ(COREQUEST_OK, ServerDataResult.ServerResponse.RequestResult);
1088         EXPECT_EQ("", ServerDataResult.ServerResponse.EntityTag);
1089         EXPECT_EQ(200, ServerDataResult.ServerResponse.ResultCode);
1090         EXPECT_EQ(0, ServerDataResult.ServerResponse.SessionCode);
1091         EXPECT_EQ("", ServerDataResult.ServerResponse.ResultMessage);
1092
1093         EXPECT_EQ("5964589-43543534", ServerDataResult.SyncToken);
1094
1095         EXPECT_EQ(1, ServerDataResult.ListData.size());
1096
1097         EXPECT_EQ("/location3.vcf", ServerDataResult.ListData[0].Location);
1098         EXPECT_EQ(ContactFile3, ServerDataResult.ListData[0].Data);
1099
1100 }
1101
1102 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Get_A_Contact_List_Due_To_Invalid_Permissions){
1103
1104         std::string ServerAddress1 = "gibberish.invalid";
1105         std::string ServerUser1 = "user";
1106         std::string ServerPass1 = "pass";
1107
1108         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
1109         FakeConnection.ResultServerPrefix = "/prefix/test/b";
1110         FakeConnection.Connect();
1111
1112         COContactList ContactListSetup;
1113         ContactListSetup.SyncToken = "";
1114
1115         FakeConnection.TestContactList = ContactListSetup;
1116         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
1117         FakeConnection.TestEntityTag = "";
1118         FakeConnection.TestResultCode = 403;
1119         FakeConnection.TestSessionCode = 22;
1120         FakeConnection.TestResultMessage = "You do not have permission to access this resource.";
1121
1122         COContactList ServerDataResult = FakeConnection.GetContactList("");
1123
1124         EXPECT_EQ(COREQUEST_ERROR_SERVER, ServerDataResult.ServerResponse.RequestResult);
1125         EXPECT_EQ("", ServerDataResult.ServerResponse.EntityTag);
1126         EXPECT_EQ(403, ServerDataResult.ServerResponse.ResultCode);
1127         EXPECT_EQ(22, ServerDataResult.ServerResponse.SessionCode);
1128         EXPECT_EQ("You do not have permission to access this resource.", ServerDataResult.ServerResponse.ResultMessage);
1129
1130         EXPECT_EQ(0, ServerDataResult.ListData.size());
1131
1132 }
1133
1134 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Get_A_Contact_List_Due_To_Missing_Resource){
1135
1136         std::string ServerAddress1 = "gibberish.invalid";
1137         std::string ServerUser1 = "user";
1138         std::string ServerPass1 = "pass";
1139
1140         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
1141         FakeConnection.ResultServerPrefix = "/prefix/test/b";
1142         FakeConnection.Connect();
1143
1144         COContactList ContactListSetup;
1145         ContactListSetup.SyncToken = "";
1146
1147         FakeConnection.TestContactList = ContactListSetup;
1148         FakeConnection.TestRequestResult = COREQUEST_ERROR_SERVER;
1149         FakeConnection.TestEntityTag = "";
1150         FakeConnection.TestResultCode = 404;
1151         FakeConnection.TestSessionCode = 22;
1152         FakeConnection.TestResultMessage = "The resource could not be found.";
1153
1154         COContactList ServerDataResult = FakeConnection.GetContactList("");
1155
1156         EXPECT_EQ(COREQUEST_ERROR_SERVER, ServerDataResult.ServerResponse.RequestResult);
1157         EXPECT_EQ("", ServerDataResult.ServerResponse.EntityTag);
1158         EXPECT_EQ(404, ServerDataResult.ServerResponse.ResultCode);
1159         EXPECT_EQ(22, ServerDataResult.ServerResponse.SessionCode);
1160         EXPECT_EQ("The resource could not be found.", ServerDataResult.ServerResponse.ResultMessage);
1161
1162         EXPECT_EQ(0, ServerDataResult.ListData.size());
1163
1164 }
1165
1166 TEST(CardDAV, Use_Fake_To_Simulate_A_Connection_That_Fails_To_Get_A_Contact_List_Due_To_No_Connection){
1167
1168         std::string ServerAddress1 = "gibberish.invalid";
1169         std::string ServerUser1 = "user";
1170         std::string ServerPass1 = "pass";
1171
1172         FakeConnectionObject FakeConnection(ServerAddress1, 8080, ServerUser1, ServerPass1, true, "/prefix", "Account1");
1173         FakeConnection.ResultServerPrefix = "/prefix/test/b";
1174         FakeConnection.Connect();
1175
1176         COContactList ContactListSetup;
1177         ContactListSetup.SyncToken = "";
1178
1179         FakeConnection.TestContactList = ContactListSetup;
1180         FakeConnection.TestRequestResult = COREQUEST_ERROR_NOTCONNECTED;
1181         FakeConnection.TestEntityTag = "";
1182         FakeConnection.TestResultCode = 404;
1183         FakeConnection.TestSessionCode = 22;
1184         FakeConnection.TestResultMessage = "The resource could not be found.";
1185
1186         COContactList ServerDataResult = FakeConnection.GetContactList("");
1187
1188         EXPECT_EQ(COREQUEST_ERROR_NOTCONNECTED, ServerDataResult.ServerResponse.RequestResult);
1189         EXPECT_EQ("", ServerDataResult.ServerResponse.EntityTag);
1190         EXPECT_EQ(404, ServerDataResult.ServerResponse.ResultCode);
1191         EXPECT_EQ(22, ServerDataResult.ServerResponse.SessionCode);
1192         EXPECT_EQ("The resource could not be found.", ServerDataResult.ServerResponse.ResultMessage);
1193
1194         EXPECT_EQ(0, ServerDataResult.ListData.size());
1195
1196 }