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