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