source/tests/xestiacalendar_caldav.h

   1 // xestiacalendar_caldav.h - Xestia Calendar CalDAV Object Unit Tests
   2 //
   3 // (c) 2016 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Calendar.
   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 Calendar. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "../objects/CalDAV/CalDAV.h"
  20 #include "xestiacalendar_testcommon.h"
  21 #include <iostream>
  22 #include <map>
  23
  24 using namespace std;
  25
  26 TEST(CalDAV, BasicTests){
  27
  28         CalDAVConnectionData ConnPlain;
  29         CalDAVConnectionData ConnNormal;
  30         CalDAVConnectionData ConnInvalidSSL;
  31         CalDAVConnectionData ConnTimeout;
  32         ProcessConnectionDataFileResult DataFileResult;
  33
  34         bool ValidDataPlain = false;
  35         bool ValidDataNormal = false;
  36         bool ValidDataInvalidSSL = false;
  37         bool ValidDataTimeout = false;
  38
  39         // Attempt to read the caldavtest-plain.auth file.
  40
  41         DataFileResult = ProcessConnectionDataFile("caldavtest-plain.auth", &ConnPlain);
  42         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
  43                 ValidDataPlain = true;
  44         }
  45
  46         // Attempt to read the caldavtest.auth file.
  47
  48         DataFileResult = ProcessConnectionDataFile("caldavtest.auth", &ConnNormal);
  49         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
  50                 ValidDataNormal = true;
  51         }
  52
  53         // Attempt to read the caldavtest-fail.auth file.
  54
  55         DataFileResult = ProcessConnectionDataFile("caldavtest-fail.auth", &ConnInvalidSSL);
  56         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
  57                 ValidDataInvalidSSL = true;
  58         }
  59
  60         // Attempt to read the caldavtest-timeout.auth file.
  61
  62         DataFileResult = ProcessConnectionDataFile("caldavtest-timeout.auth", &ConnTimeout);
  63         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
  64                 ValidDataTimeout = true;
  65         }
  66
  67         if (ValidDataPlain == false){
  68
  69                 // Cannot read the caldavtest-plain.auth file properly.
  70
  71                 cout << "The caldavtest-plain.auth file does not exist or is invalid!" << endl;
  72                 cout << "Please create the caldavtest-plain.auth file using the following format:" << endl << endl;
  73                 cout << "server=localname" << endl;
  74                 cout << "port=8080" << endl;
  75                 cout << "user=username" << endl;
  76                 cout << "pass=password" << endl;
  77                 cout << "ssl=false" << endl;
  78                 cout << "prefix=/lalala/lookatme/thisisa/prefix" << endl << endl;
  79
  80         }
  81
  82         if (ValidDataNormal == false){
  83
  84                 // Cannot read the caldavtest.auth file properly.
  85
  86                 cout << "The caldavtest.auth file does not exist or is invalid!" << endl;
  87                 cout << "Please create the caldavtest.auth file using the following format:" << endl << endl;
  88                 cout << "server=localname" << endl;
  89                 cout << "port=8080" << endl;
  90                 cout << "user=username" << endl;
  91                 cout << "pass=password" << endl;
  92                 cout << "ssl=false" << endl;
  93                 cout << "prefix=/lalala/lookatme/thisisa/prefix" << endl << endl;
  94
  95         }
  96
  97         if (ValidDataInvalidSSL == false){
  98
  99                 // Cannot read the caldavtest-fail.auth file properly.
 100
 101                 cout << "The caldavtest-fail.auth file does not exist or is invalid!" << endl;
 102                 cout << "Please create the caldavtest-fail.auth file using the following format:" << endl << endl;
 103                 cout << "server=fail.localname" << endl;
 104                 cout << "port=8080" << endl;
 105                 cout << "user=username" << endl;
 106                 cout << "pass=password" << endl;
 107                 cout << "ssl=false" << endl;
 108                 cout << "prefix=/lalala/lookatme/thisisa/prefix" << endl << endl;
 109
 110         }
 111
 112         if (ValidDataTimeout == false){
 113
 114                 // Cannot read the caldavtest-timeout.auth file properly.
 115
 116                 cout << "The caldavtest-timeout.auth file does not exist or is invalid!" << endl;
 117                 cout << "Please create the caldavtest-timeout.auth file using the following format:" << endl << endl;
 118                 cout << "server=fail.localname" << endl;
 119                 cout << "port=8080" << endl;
 120                 cout << "user=username" << endl;
 121                 cout << "pass=password" << endl;
 122                 cout << "ssl=false" << endl;
 123                 cout << "prefix=/lalala/lookatme/thisisa/prefix" << endl << endl;
 124
 125         }
 126
 127         ASSERT_EQ(true, ValidDataPlain);
 128         ASSERT_EQ(true, ValidDataNormal);
 129         ASSERT_EQ(true, ValidDataInvalidSSL);
 130         ASSERT_EQ(true, ValidDataTimeout);
 131
 132         // (*nix version) Setup an initial connection (just plain
 133         // text).
 134
 135         CalDAV CalDAVPlain;
 136         CalDAVPlain.SetupConnectionData(&ConnPlain);
 137
 138         // Verify that the settings match with the CalDAVConnectionData
 139         // passed.
 140
 141         CalDAVStatus CalDAVPlainStatus = CalDAVPlain.GetConnectionData();
 142
 143         ASSERT_EQ(CalDAVPlainStatus.Hostname, ConnPlain.Hostname);
 144         ASSERT_EQ(CalDAVPlainStatus.Username, ConnPlain.Username);
 145         ASSERT_EQ(CalDAVPlainStatus.Port, ConnPlain.Port);
 146         ASSERT_EQ(CalDAVPlainStatus.Prefix, ConnPlain.Prefix);
 147         ASSERT_EQ(CalDAVPlainStatus.UseSSL, ConnPlain.UseSSL);
 148
 149         // Verify that the connection was successful.
 150
 151         CalDAVServerResult ConnResult = CalDAVPlain.Connect();
 152
 153         ASSERT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 154         ASSERT_EQ(200, ConnResult.HTTPCode);
 155         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 156
 157         // Do another connection and this time the connection should
 158         // fail due to being an invalid host name.
 159
 160         CalDAVConnectionData ConnPlainFail;
 161         ConnPlainFail.Hostname = "server.invalid";
 162         ConnPlainFail.Username = "fail";
 163         ConnPlainFail.Password = "fail";
 164         ConnPlainFail.Port = 80;
 165         ConnPlainFail.UseSSL = false;
 166
 167         // Setup the CalDAV connection object.
 168
 169         CalDAV CalDAVPlainFail;
 170         CalDAVPlainFail.SetupConnectionData(&ConnPlainFail);
 171
 172         // Setup the CalDAVStatus object.
 173
 174         CalDAVStatus CalDAVPlainFailStatus = CalDAVPlain.GetConnectionData();
 175
 176         // Connect and fail.
 177
 178         ConnResult = CalDAVPlainFail.Connect();
 179
 180         ASSERT_EQ(CALDAVQUERYRESULT_SERVERERROR, ConnResult.Result);
 181         ASSERT_EQ(0, ConnResult.HTTPCode);
 182         ASSERT_EQ(CURLE_COULDNT_RESOLVE_HOST, ConnResult.Code);
 183
 184         // (*nix version) Setup an initial connection (with a valid
 185         // SSL certificate).
 186
 187         CalDAV CalDAVNormal;
 188         CalDAVNormal.SetupConnectionData(&ConnNormal);
 189
 190         // Verify that the settings match with the CalDAVConnectionData
 191         // passed.
 192
 193         CalDAVStatus CalDAVNormalStatus = CalDAVNormal.GetConnectionData();
 194
 195         ASSERT_EQ(CalDAVNormalStatus.Hostname, ConnNormal.Hostname);
 196         ASSERT_EQ(CalDAVNormalStatus.Username, ConnNormal.Username);
 197         ASSERT_EQ(CalDAVNormalStatus.Port, ConnNormal.Port);
 198         ASSERT_EQ(CalDAVNormalStatus.Prefix, ConnNormal.Prefix);
 199         ASSERT_EQ(CalDAVNormalStatus.UseSSL, ConnNormal.UseSSL);
 200
 201         // Verify that the connection was successful (with a valid
 202         // SSL certificate).
 203
 204         ConnResult = CalDAVNormal.Connect();
 205
 206         ASSERT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 207         ASSERT_EQ(200, ConnResult.HTTPCode);
 208         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 209
 210         // (*nix version) Setup an initial connection on a server that
 211         // will fail due to having an invalid SSL certificate.
 212
 213         CalDAV CalDAVInvalidSSL;
 214         CalDAVInvalidSSL.SetupConnectionData(&ConnInvalidSSL);
 215
 216         // Verify that the settings match with the CalDAVConnectionData
 217         // passed.
 218
 219         CalDAVStatus CalDAVInvalidSSLStatus = CalDAVInvalidSSL.GetConnectionData();
 220
 221         ASSERT_EQ(CalDAVInvalidSSLStatus.Hostname, ConnInvalidSSL.Hostname);
 222         ASSERT_EQ(CalDAVInvalidSSLStatus.Username, ConnInvalidSSL.Username);
 223         ASSERT_EQ(CalDAVInvalidSSLStatus.Port, ConnInvalidSSL.Port);
 224         ASSERT_EQ(CalDAVInvalidSSLStatus.Prefix, ConnInvalidSSL.Prefix);
 225         ASSERT_EQ(CalDAVInvalidSSLStatus.UseSSL, ConnInvalidSSL.UseSSL);
 226
 227         // Verify that the connection had failed. (with an invalid
 228         // SSL certificate).
 229
 230         ConnResult = CalDAVInvalidSSL.Connect();
 231
 232         ASSERT_EQ(CALDAVQUERYRESULT_SERVERERROR, ConnResult.Result);
 233         ASSERT_EQ(0, ConnResult.HTTPCode);
 234         ASSERT_EQ(CURLE_SSL_CACERT, ConnResult.Code);
 235
 236         // (*nix version) Setup an inital connection on a server where
 237         // a timeout occurs.
 238
 239         ConnTimeout.Timeout = 5;
 240
 241         CalDAV CalDAVTimeout;
 242         CalDAVTimeout.SetupConnectionData(&ConnTimeout);
 243
 244         // Verify that the settings match with the CalDAVConnectionData
 245         // passed.
 246
 247         CalDAVStatus CalDAVTimeoutStatus = CalDAVTimeout.GetConnectionData();
 248
 249         ASSERT_EQ(CalDAVTimeoutStatus.Hostname, ConnTimeout.Hostname);
 250         ASSERT_EQ(CalDAVTimeoutStatus.Username, ConnTimeout.Username);
 251         ASSERT_EQ(CalDAVTimeoutStatus.Port, ConnTimeout.Port);
 252         ASSERT_EQ(CalDAVTimeoutStatus.Prefix, ConnTimeout.Prefix);
 253         ASSERT_EQ(CalDAVTimeoutStatus.Timeout, ConnTimeout.Timeout);
 254         ASSERT_EQ(CalDAVTimeoutStatus.UseSSL, ConnTimeout.UseSSL);
 255
 256         // Verify that the connection had timed out.
 257
 258         ConnResult = CalDAVTimeout.Connect();
 259
 260         ASSERT_EQ(CALDAVQUERYRESULT_SERVERERROR, ConnResult.Result);
 261         ASSERT_EQ(0, ConnResult.HTTPCode);
 262         ASSERT_EQ(CURLE_OPERATION_TIMEDOUT, ConnResult.Code);
 263
 264 }
 265
 266 TEST(CalDAV, BuildServerAddress){
 267
 268         CalDAVConnectionData ConnNormal;
 269         ProcessConnectionDataFileResult DataFileResult;
 270         bool ValidDataNormal = false;
 271
 272         // Attempt to read the caldavtest.auth file.
 273
 274         DataFileResult = ProcessConnectionDataFile("caldavtest.auth", &ConnNormal);
 275         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
 276                 ValidDataNormal = true;
 277         }
 278
 279         if (ValidDataNormal == false){
 280
 281                 // Cannot read the caldavtest.auth file properly.
 282
 283                 cout << "The caldavtest.auth file does not exist or is invalid!" << endl;
 284                 cout << "Please create the caldavtest.auth file using the following format:" << endl << endl;
 285                 cout << "server=localname" << endl;
 286                 cout << "port=8080" << endl;
 287                 cout << "user=username" << endl;
 288                 cout << "pass=password" << endl;
 289                 cout << "ssl=false" << endl;
 290                 cout << "prefix=/lalala/lookatme/thisisa/prefix" << endl << endl;
 291
 292         }
 293
 294         ASSERT_EQ(true, ValidDataNormal);
 295
 296         // Setup the server address to check.
 297
 298         string ServerAddress;
 299
 300         // Setup the server address.
 301
 302         if (ConnNormal.UseSSL == true){
 303                 ServerAddress += "https://";
 304         } else {
 305                 ServerAddress += "http://";
 306         }
 307
 308         ServerAddress += ConnNormal.Hostname;
 309
 310         // Check if server port is 80, otherwise
 311         // specifiy the port number in the address.
 312
 313         if (ConnNormal.Port != 80){
 314                 ServerAddress += ":";
 315                 ServerAddress += to_string(ConnNormal.Port);
 316         }
 317
 318         ServerAddress += "/principals/";
 319
 320         ASSERT_EQ(ServerAddress, BuildServerAddress(&ConnNormal, "/principals/"));
 321
 322 }
 323
 324 TEST(CalDAV, CalendarServerSupport){
 325
 326         CalDAVConnectionData ConnNormal;
 327
 328         bool ValidDataNormal = false;
 329
 330         // Attempt to read the caldavtest.auth file.
 331
 332         ProcessConnectionDataFileResult DataFileResult = ProcessConnectionDataFile("caldavtest.auth", &ConnNormal);
 333         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
 334                 ValidDataNormal = true;
 335         }
 336
 337         ASSERT_EQ(true, ValidDataNormal);
 338
 339         // Setup the connection.
 340
 341         CalDAV ServerConnection;
 342
 343         ServerConnection.SetupConnectionData(&ConnNormal);
 344
 345         // Verify the connection settings.
 346
 347         CalDAVStatus CalDAVStatus = ServerConnection.GetConnectionData();
 348
 349         ASSERT_EQ(CalDAVStatus.Hostname, ConnNormal.Hostname);
 350         ASSERT_EQ(CalDAVStatus.Username, ConnNormal.Username);
 351         ASSERT_EQ(CalDAVStatus.Port, ConnNormal.Port);
 352         ASSERT_EQ(CalDAVStatus.Prefix, ConnNormal.Prefix);
 353         ASSERT_EQ(CalDAVStatus.UseSSL, ConnNormal.UseSSL);
 354
 355         // Connect to the server.
 356
 357         CalDAVServerResult ConnResult = ServerConnection.Connect();
 358
 359         ASSERT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 360         ASSERT_EQ(200, ConnResult.HTTPCode);
 361         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 362
 363         // Check for basic support of the calendar server.
 364
 365         CalDAVServerSupport ConnSupport = ServerConnection.GetServerSupport();
 366
 367         ASSERT_EQ(true, ConnSupport.BasicSupport);
 368
 369 }
 370
 371 TEST(CalDAV, GetCalendarHome){
 372
 373         CalDAVConnectionData ConnNormal;
 374
 375         bool ValidDataNormal = false;
 376
 377         // Attempt to read the caldavtest.auth file.
 378
 379         ProcessConnectionDataFileResult DataFileResult = ProcessConnectionDataFile("caldavtest.auth", &ConnNormal);
 380         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
 381                 ValidDataNormal = true;
 382         }
 383
 384         ASSERT_EQ(true, ValidDataNormal);
 385
 386         // Setup the connection.
 387
 388         CalDAV ServerConnection;
 389
 390         ServerConnection.SetupConnectionData(&ConnNormal);
 391
 392         // Verify the connection settings.
 393
 394         CalDAVStatus CalDAVStatus = ServerConnection.GetConnectionData();
 395
 396         ASSERT_EQ(CalDAVStatus.Hostname, ConnNormal.Hostname);
 397         ASSERT_EQ(CalDAVStatus.Username, ConnNormal.Username);
 398         ASSERT_EQ(CalDAVStatus.Port, ConnNormal.Port);
 399         ASSERT_EQ(CalDAVStatus.Prefix, ConnNormal.Prefix);
 400         ASSERT_EQ(CalDAVStatus.UseSSL, ConnNormal.UseSSL);
 401
 402         // Connect to the server.
 403
 404         CalDAVServerResult ConnResult = ServerConnection.Connect();
 405
 406         ASSERT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 407         ASSERT_EQ(200, ConnResult.HTTPCode);
 408         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 409
 410         // Check for basic support of the calendar server.
 411
 412         CalDAVServerSupport ConnSupport = ServerConnection.GetServerSupport();
 413
 414         ASSERT_EQ(true, ConnSupport.BasicSupport);
 415
 416         // Get the user principal.
 417
 418         string CurrentUserPrincipal = ServerConnection.GetUserPrincipal();
 419
 420         // Check the response from the server.
 421
 422         ConnResult = ServerConnection.GetServerResult();
 423
 424         EXPECT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 425         ASSERT_EQ(207, ConnResult.HTTPCode);
 426         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 427
 428         // Get the calendar home.
 429
 430         string CalendarHome = ServerConnection.GetCalendarHome(CurrentUserPrincipal);
 431
 432         // Check the response from the server.
 433
 434         ConnResult = ServerConnection.GetServerResult();
 435
 436         EXPECT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 437         ASSERT_EQ(207, ConnResult.HTTPCode);
 438         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 439
 440 }
 441
 442 TEST(CalDAV, ListCalendars){
 443
 444         CalDAVConnectionData ConnNormal;
 445         string CurrentUserPrincipal;
 446
 447         bool ValidDataNormal = false;
 448
 449         // Attempt to read the caldavtest.auth file.
 450
 451         ProcessConnectionDataFileResult DataFileResult = ProcessConnectionDataFile("caldavtest.auth", &ConnNormal);
 452         if (DataFileResult == PROCESSCONNECTIONDATAFILE_OK){
 453                 ValidDataNormal = true;
 454         }
 455
 456         ASSERT_EQ(true, ValidDataNormal);
 457
 458         // Setup the connection.
 459
 460         CalDAV ServerConnection;
 461
 462         ServerConnection.SetupConnectionData(&ConnNormal);
 463
 464         // Verify the connection settings.
 465
 466         CalDAVStatus CalDAVStatus = ServerConnection.GetConnectionData();
 467
 468         ASSERT_EQ(CalDAVStatus.Hostname, ConnNormal.Hostname);
 469         ASSERT_EQ(CalDAVStatus.Username, ConnNormal.Username);
 470         ASSERT_EQ(CalDAVStatus.Port, ConnNormal.Port);
 471         ASSERT_EQ(CalDAVStatus.Prefix, ConnNormal.Prefix);
 472         ASSERT_EQ(CalDAVStatus.UseSSL, ConnNormal.UseSSL);
 473
 474         // Connect to the server.
 475
 476         CalDAVServerResult ConnResult = ServerConnection.Connect();
 477
 478         EXPECT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 479         ASSERT_EQ(200, ConnResult.HTTPCode);
 480         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 481
 482         // Check that the server supports CalDAV.
 483
 484         CalDAVServerSupport ConnSupport = ServerConnection.GetServerSupport();
 485         ConnResult = ServerConnection.GetServerResult();
 486
 487         EXPECT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 488         ASSERT_EQ(200, ConnResult.HTTPCode);
 489         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 490         ASSERT_EQ(true, ConnSupport.BasicSupport);
 491
 492         // Get the list of calendars.
 493
 494         CalDAVCalendarList CalendarList = ServerConnection.GetCalendars();
 495
 496         // Check the response result from the server.
 497
 498         ConnResult = ServerConnection.GetServerResult();
 499
 500         EXPECT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 501         ASSERT_EQ(200, ConnResult.HTTPCode);
 502         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 503
 504         // Get the user principal.
 505
 506         CurrentUserPrincipal = ServerConnection.GetUserPrincipal();
 507
 508         // Check the response from the server.
 509
 510         ConnResult = ServerConnection.GetServerResult();
 511
 512         EXPECT_EQ(CALDAVQUERYRESULT_OK, ConnResult.Result);
 513         ASSERT_EQ(207, ConnResult.HTTPCode);
 514         ASSERT_EQ(CURLE_OK, ConnResult.Code);
 515
 516         // Get the list of calendars.
 517
 518
 519
 520
 521
 522 }