sdk/R/tests/testthat/test-RESTService.R

   1 source("fakes/FakeArvados.R")
   2 source("fakes/FakeHttpRequest.R")
   3 source("fakes/FakeHttpParser.R")
   4
   5 context("REST service")
   6
   7 test_that("getWebDavHostName calls REST service properly", {
   8
   9     expectedURL <- "https://host/discovery/v1/apis/arvados/v1/rest"
  10     serverResponse <- list(keepWebServiceUrl = "https://myWebDavServer.com")
  11     httpRequest <- FakeHttpRequest$new(expectedURL, serverResponse)
  12
  13     REST <- RESTService$new("token", "host",
  14                             httpRequest, FakeHttpParser$new())
  15
  16     REST$getWebDavHostName()
  17
  18     expect_that(httpRequest$URLIsProperlyConfigured, is_true())
  19     expect_that(httpRequest$requestHeaderContainsAuthorizationField, is_true())
  20     expect_that(httpRequest$numberOfGETRequests, equals(1))
  21 })
  22
  23 test_that("getWebDavHostName returns webDAV host name properly", {
  24
  25     serverResponse <- list(keepWebServiceUrl = "https://myWebDavServer.com")
  26     httpRequest <- FakeHttpRequest$new(expectedURL = NULL, serverResponse)
  27
  28     REST <- RESTService$new("token", "host",
  29                             httpRequest, FakeHttpParser$new())
  30
  31     expect_that("https://myWebDavServer.com", equals(REST$getWebDavHostName()))
  32 })
  33
  34 test_that("getResource calls REST service properly", {
  35
  36     serverResponse <- NULL
  37     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
  38     expectedURL    <- paste0("https://host/arvados/v1/collections/", resourceUUID)
  39
  40     httpRequest <- FakeHttpRequest$new(expectedURL, serverResponse)
  41
  42     REST <- RESTService$new("token", "host",
  43                             httpRequest, FakeHttpParser$new(),
  44                             0, "webDavHost")
  45
  46     REST$getResource("collections", resourceUUID)
  47
  48     expect_that(httpRequest$URLIsProperlyConfigured, is_true())
  49     expect_that(httpRequest$requestHeaderContainsAuthorizationField, is_true())
  50     expect_that(httpRequest$numberOfGETRequests, equals(1))
  51 })
  52
  53 test_that("getResource parses server response", {
  54
  55     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
  56     httpParser <- FakeHttpParser$new()
  57     REST <- RESTService$new("token", "host",
  58                             FakeHttpRequest$new(), httpParser,
  59                             0, "webDavHost")
  60
  61     REST$getResource("collections", resourceUUID)
  62
  63     expect_that(httpParser$parserCallCount, equals(1))
  64 })
  65
  66 test_that("getResource raises exception if response contains errors field", {
  67
  68     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
  69     serverResponse <- list(errors = 404)
  70
  71     REST <- RESTService$new("token", "host",
  72                             FakeHttpRequest$new(NULL, serverResponse),
  73                             FakeHttpParser$new(),
  74                             0, "webDavHost")
  75
  76     expect_that(REST$getResource("collections", resourceUUID), throws_error("404", fixed = TRUE))
  77 })
  78
  79 test_that("listResources calls REST service properly", {
  80
  81     serverResponse <- NULL
  82     expectedURL    <- paste0("https://host/arvados/v1/collections")
  83     httpRequest <- FakeHttpRequest$new(expectedURL, serverResponse)
  84
  85     REST <- RESTService$new("token", "host",
  86                             httpRequest, FakeHttpParser$new(),
  87                             0, "webDavHost")
  88
  89     REST$listResources("collections")
  90
  91     expect_that(httpRequest$URLIsProperlyConfigured, is_true())
  92     expect_that(httpRequest$requestHeaderContainsAuthorizationField, is_true())
  93     expect_that(httpRequest$numberOfGETRequests, equals(1))
  94 })
  95
  96 test_that("listResources parses server response", {
  97
  98     httpParser <- FakeHttpParser$new()
  99     REST <- RESTService$new("token", "host",
 100                             FakeHttpRequest$new(), httpParser,
 101                             0, "webDavHost")
 102
 103     REST$listResources("collections")
 104
 105     expect_that(httpParser$parserCallCount, equals(1))
 106 })
 107
 108 test_that("listResources raises exception if response contains errors field", {
 109
 110     serverResponse <- list(errors = 404)
 111
 112     REST <- RESTService$new("token", "host",
 113                             FakeHttpRequest$new(NULL, serverResponse),
 114                             FakeHttpParser$new(),
 115                             0, "webDavHost")
 116
 117     expect_that(REST$listResources("collections"), throws_error("404", fixed = TRUE))
 118 })
 119
 120 test_that("fetchAllItems always returns all resource items from server", {
 121
 122     expectedURL <- NULL
 123     serverResponse <- list(items_available = 8,
 124                            items = list("collection1",
 125                                         "collection2",
 126                                         "collection3",
 127                                         "collection4",
 128                                         "collection5",
 129                                         "collection6",
 130                                         "collection7",
 131                                         "collection8"))
 132
 133     httpParser <- FakeHttpParser$new()
 134     httpRequest <- FakeHttpRequest$new(expectedURL, serverResponse)
 135     httpRequest$serverMaxElementsPerRequest <- 3
 136
 137     REST <- RESTService$new("token", "host",
 138                             httpRequest, httpParser,
 139                             0, "webDavHost")
 140
 141     result <- REST$fetchAllItems(NULL, NULL)
 142
 143     expect_that(length(result), equals(8))
 144     expect_that(httpRequest$numberOfGETRequests, equals(3))
 145     expect_that(httpParser$parserCallCount, equals(3))
 146 })
 147
 148 test_that("deleteResource calls REST service properly", {
 149
 150     serverResponse <- NULL
 151     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 152     expectedURL    <- paste0("https://host/arvados/v1/collections/", resourceUUID)
 153
 154     httpRequest <- FakeHttpRequest$new(expectedURL, serverResponse)
 155
 156     REST <- RESTService$new("token", "host",
 157                             httpRequest, FakeHttpParser$new(),
 158                             0, "webDavHost")
 159
 160     REST$deleteResource("collections", resourceUUID)
 161
 162     expect_that(httpRequest$URLIsProperlyConfigured, is_true())
 163     expect_that(httpRequest$requestHeaderContainsAuthorizationField, is_true())
 164     expect_that(httpRequest$numberOfDELETERequests, equals(1))
 165 })
 166
 167 test_that("deleteCollection parses server response", {
 168
 169     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 170     httpParser <- FakeHttpParser$new()
 171     REST <- RESTService$new("token", "host",
 172                             FakeHttpRequest$new(), httpParser,
 173                             0, "webDavHost")
 174
 175     REST$deleteResource("collections", resourceUUID)
 176
 177     expect_that(httpParser$parserCallCount, equals(1))
 178 })
 179
 180 test_that("deleteCollection raises exception if response contains errors field", {
 181
 182     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 183     serverResponse <- list(errors = 404)
 184
 185     REST <- RESTService$new("token", "host",
 186                             FakeHttpRequest$new(NULL, serverResponse),
 187                             FakeHttpParser$new(),
 188                             0, "webDavHost")
 189
 190     expect_that(REST$deleteResource("collections", resourceUUID), throws_error("404", fixed = TRUE))
 191 })
 192
 193 test_that("updateResource calls REST service properly", {
 194
 195     serverResponse <- NULL
 196     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 197     expectedURL    <- paste0("https://host/arvados/v1/collections/", resourceUUID)
 198     newResourceContent <- list(newName = "Brand new shiny name")
 199
 200     httpRequest <- FakeHttpRequest$new(expectedURL, serverResponse)
 201
 202     REST <- RESTService$new("token", "host",
 203                             httpRequest, FakeHttpParser$new(),
 204                             0, "webDavHost")
 205
 206     REST$updateResource("collections", resourceUUID, newResourceContent)
 207
 208     expect_that(httpRequest$URLIsProperlyConfigured, is_true())
 209     expect_that(httpRequest$requestHeaderContainsAuthorizationField, is_true())
 210     expect_that(httpRequest$JSONEncodedBodyIsProvided, is_true())
 211     expect_that(httpRequest$numberOfPUTRequests, equals(1))
 212 })
 213
 214 test_that("updateResource parses server response", {
 215
 216     newResourceContent <- list(newName = "Brand new shiny name")
 217     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 218     httpParser <- FakeHttpParser$new()
 219     REST <- RESTService$new("token", "host",
 220                             FakeHttpRequest$new(), httpParser,
 221                             0, "webDavHost")
 222
 223     REST$updateResource("collections", resourceUUID, newResourceContent)
 224
 225     expect_that(httpParser$parserCallCount, equals(1))
 226 })
 227
 228 test_that("updateResource raises exception if response contains errors field", {
 229
 230     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 231     serverResponse <- list(errors = 404)
 232     newResourceContent <- list(newName = "Brand new shiny name")
 233     REST <- RESTService$new("token", "host",
 234                             FakeHttpRequest$new(NULL, serverResponse),
 235                             FakeHttpParser$new(),
 236                             0, "webDavHost")
 237
 238     expect_that(REST$updateResource("collections", resourceUUID, newResourceContent),
 239                 throws_error("404", fixed = TRUE))
 240 })
 241
 242 test_that("createResource calls REST service properly", {
 243
 244     resourceContent <- list(name = "My favorite collection")
 245     serverResponse <- NULL
 246     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 247     expectedURL <- "https://host/arvados/v1/collections"
 248     newResourceContent <- list(newName = "Brand new shiny name")
 249
 250     httpRequest <- FakeHttpRequest$new(expectedURL, serverResponse)
 251
 252     REST <- RESTService$new("token", "host",
 253                             httpRequest, FakeHttpParser$new(),
 254                             0, "webDavHost")
 255
 256     REST$createResource("collections", resourceContent)
 257
 258     expect_that(httpRequest$URLIsProperlyConfigured, is_true())
 259     expect_that(httpRequest$requestHeaderContainsAuthorizationField, is_true())
 260     expect_that(httpRequest$JSONEncodedBodyIsProvided, is_true())
 261     expect_that(httpRequest$numberOfPOSTRequests, equals(1))
 262 })
 263
 264 test_that("createResource parses server response", {
 265
 266     resourceContent <- list(newName = "Brand new shiny name")
 267     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 268     httpParser <- FakeHttpParser$new()
 269     REST <- RESTService$new("token", "host",
 270                             FakeHttpRequest$new(), httpParser,
 271                             0, "webDavHost")
 272
 273     REST$createResource("collections", resourceContent)
 274
 275     expect_that(httpParser$parserCallCount, equals(1))
 276 })
 277
 278 test_that("createResource raises exception if response contains errors field", {
 279
 280     resourceUUID <- "aaaaa-j7d0g-ccccccccccccccc"
 281     serverResponse <- list(errors = 404)
 282     resourceContent <- list(newName = "Brand new shiny name")
 283     REST <- RESTService$new("token", "host",
 284                             FakeHttpRequest$new(NULL, serverResponse),
 285                             FakeHttpParser$new(),
 286                             0, "webDavHost")
 287
 288     expect_that(REST$createResource("collections", resourceContent),
 289                 throws_error("404", fixed = TRUE))
 290 })
 291
 292 test_that("create calls REST service properly", {
 293
 294     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 295     expectedURL <- "https://webDavHost/c=aaaaa-j7d0g-ccccccccccccccc/file"
 296     fakeHttp <- FakeHttpRequest$new(expectedURL)
 297     fakeHttpParser <- FakeHttpParser$new()
 298
 299     REST <- RESTService$new("token", "https://host/",
 300                             fakeHttp, fakeHttpParser,
 301                             0, "https://webDavHost/")
 302
 303     REST$create("file", uuid)
 304
 305     expect_that(fakeHttp$URLIsProperlyConfigured, is_true())
 306     expect_that(fakeHttp$requestHeaderContainsAuthorizationField, is_true())
 307     expect_that(fakeHttp$numberOfPUTRequests, equals(1))
 308 })
 309
 310 test_that("create raises exception if server response code is not between 200 and 300", {
 311
 312     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 313     response <- list()
 314     response$status_code <- 404
 315     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 316
 317     REST <- RESTService$new("token", "https://host/",
 318                             fakeHttp, HttpParser$new(),
 319                             0, "https://webDavHost/")
 320
 321     expect_that(REST$create("file", uuid),
 322                 throws_error("Server code: 404"))
 323 })
 324
 325 test_that("delete calls REST service properly", {
 326
 327     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 328     expectedURL <- "https://webDavHost/c=aaaaa-j7d0g-ccccccccccccccc/file"
 329     fakeHttp <- FakeHttpRequest$new(expectedURL)
 330     fakeHttpParser <- FakeHttpParser$new()
 331
 332     REST <- RESTService$new("token", "https://host/",
 333                             fakeHttp, fakeHttpParser,
 334                             0, "https://webDavHost/")
 335
 336     REST$delete("file", uuid)
 337
 338     expect_that(fakeHttp$URLIsProperlyConfigured, is_true())
 339     expect_that(fakeHttp$requestHeaderContainsAuthorizationField, is_true())
 340     expect_that(fakeHttp$numberOfDELETERequests, equals(1))
 341 })
 342
 343 test_that("delete raises exception if server response code is not between 200 and 300", {
 344
 345     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 346     response <- list()
 347     response$status_code <- 404
 348     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 349
 350     REST <- RESTService$new("token", "https://host/",
 351                             fakeHttp, HttpParser$new(),
 352                             0, "https://webDavHost/")
 353
 354     expect_that(REST$delete("file", uuid),
 355                 throws_error("Server code: 404"))
 356 })
 357
 358 test_that("move calls REST service properly", {
 359
 360     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 361     expectedURL <- "https://webDavHost/c=aaaaa-j7d0g-ccccccccccccccc/file"
 362     fakeHttp <- FakeHttpRequest$new(expectedURL)
 363     fakeHttpParser <- FakeHttpParser$new()
 364
 365     REST <- RESTService$new("token", "https://host/",
 366                             fakeHttp, fakeHttpParser,
 367                             0, "https://webDavHost/")
 368
 369     REST$move("file", "newDestination/file", uuid)
 370
 371     expect_that(fakeHttp$URLIsProperlyConfigured, is_true())
 372     expect_that(fakeHttp$requestHeaderContainsAuthorizationField, is_true())
 373     expect_that(fakeHttp$requestHeaderContainsDestinationField, is_true())
 374     expect_that(fakeHttp$numberOfMOVERequests, equals(1))
 375 })
 376
 377 test_that("move raises exception if server response code is not between 200 and 300", {
 378
 379     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 380     response <- list()
 381     response$status_code <- 404
 382     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 383
 384     REST <- RESTService$new("token", "https://host/",
 385                             fakeHttp, HttpParser$new(),
 386                             0, "https://webDavHost/")
 387
 388     expect_that(REST$move("file", "newDestination/file", uuid),
 389                 throws_error("Server code: 404"))
 390 })
 391
 392 test_that("getCollectionContent retreives correct content from WebDAV server", {
 393
 394     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 395     expectedURL <- "https://webDavHost/c=aaaaa-j7d0g-ccccccccccccccc"
 396     returnContent <- list()
 397     returnContent$status_code <- 200
 398     returnContent$content <- c("animal", "animal/dog", "ball")
 399
 400     fakeHttp <- FakeHttpRequest$new(expectedURL, returnContent)
 401
 402     REST <- RESTService$new("token", "https://host/",
 403                             fakeHttp, FakeHttpParser$new(),
 404                             0, "https://webDavHost/")
 405
 406     returnResult <- REST$getCollectionContent(uuid)
 407     returnedContentMatchExpected <- all.equal(returnResult,
 408                                               c("animal", "animal/dog", "ball"))
 409
 410     expect_that(returnedContentMatchExpected, is_true())
 411     expect_that(fakeHttp$requestHeaderContainsAuthorizationField, is_true())
 412 })
 413
 414 test_that("getCollectionContent raises exception if server returns empty response", {
 415
 416     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 417     response <- ""
 418     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 419
 420     REST <- RESTService$new("token", "https://host/",
 421                             fakeHttp, FakeHttpParser$new(),
 422                             0, "https://webDavHost/")
 423
 424     expect_that(REST$getCollectionContent(uuid),
 425                 throws_error("Response is empty, request may be misconfigured"))
 426 })
 427
 428 test_that("getCollectionContent parses server response", {
 429
 430     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 431     fakeHttpParser <- FakeHttpParser$new()
 432     REST <- RESTService$new("token", "https://host/",
 433                             FakeHttpRequest$new(), fakeHttpParser,
 434                             0, "https://webDavHost/")
 435
 436     REST$getCollectionContent(uuid)
 437
 438     expect_that(fakeHttpParser$parserCallCount, equals(1))
 439 })
 440
 441 test_that("getCollectionContent raises exception if server returns empty response", {
 442
 443     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 444     response <- ""
 445     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 446
 447     REST <- RESTService$new("token", "https://host/",
 448                             fakeHttp, FakeHttpParser$new(),
 449                             0, "https://webDavHost/")
 450
 451     expect_that(REST$getCollectionContent(uuid),
 452                 throws_error("Response is empty, request may be misconfigured"))
 453 })
 454
 455 test_that(paste("getCollectionContent raises exception if server",
 456                 "response code is not between 200 and 300"), {
 457
 458     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 459     response <- list()
 460     response$status_code <- 404
 461     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 462
 463     REST <- RESTService$new("token", "https://host/",
 464                             fakeHttp, HttpParser$new(),
 465                             0, "https://webDavHost/")
 466
 467     expect_that(REST$getCollectionContent(uuid),
 468                 throws_error("Server code: 404"))
 469 })
 470
 471
 472 test_that("getResourceSize calls REST service properly", {
 473
 474     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 475     expectedURL <- "https://webDavHost/c=aaaaa-j7d0g-ccccccccccccccc/file"
 476     response <- list()
 477     response$status_code <- 200
 478     response$content <- c(6, 2, 931, 12003)
 479     fakeHttp <- FakeHttpRequest$new(expectedURL, response)
 480
 481     REST <- RESTService$new("token", "https://host/",
 482                             fakeHttp, FakeHttpParser$new(),
 483                             0, "https://webDavHost/")
 484
 485     returnResult <- REST$getResourceSize("file", uuid)
 486     returnedContentMatchExpected <- all.equal(returnResult,
 487                                               c(6, 2, 931, 12003))
 488
 489     expect_that(fakeHttp$URLIsProperlyConfigured, is_true())
 490     expect_that(fakeHttp$requestHeaderContainsAuthorizationField, is_true())
 491     expect_that(returnedContentMatchExpected, is_true())
 492 })
 493
 494 test_that("getResourceSize raises exception if server returns empty response", {
 495
 496     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 497     response <- ""
 498     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 499
 500     REST <- RESTService$new("token", "https://host/",
 501                             fakeHttp, FakeHttpParser$new(),
 502                             0, "https://webDavHost/")
 503
 504     expect_that(REST$getResourceSize("file", uuid),
 505                 throws_error("Response is empty, request may be misconfigured"))
 506 })
 507
 508 test_that(paste("getResourceSize raises exception if server",
 509                 "response code is not between 200 and 300"), {
 510
 511     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 512     response <- list()
 513     response$status_code <- 404
 514     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 515
 516     REST <- RESTService$new("token", "https://host/",
 517                             fakeHttp, HttpParser$new(),
 518                             0, "https://webDavHost/")
 519
 520     expect_that(REST$getResourceSize("file", uuid),
 521                 throws_error("Server code: 404"))
 522 })
 523
 524 test_that("getResourceSize parses server response", {
 525
 526     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 527     fakeHttpParser <- FakeHttpParser$new()
 528     REST <- RESTService$new("token", "https://host/",
 529                             FakeHttpRequest$new(), fakeHttpParser,
 530                             0, "https://webDavHost/")
 531
 532     REST$getResourceSize("file", uuid)
 533
 534     expect_that(fakeHttpParser$parserCallCount, equals(1))
 535 })
 536
 537 test_that("read calls REST service properly", {
 538
 539     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 540     expectedURL <- "https://webDavHost/c=aaaaa-j7d0g-ccccccccccccccc/file"
 541     serverResponse <- list()
 542     serverResponse$status_code <- 200
 543     serverResponse$content <- "file content"
 544
 545     fakeHttp <- FakeHttpRequest$new(expectedURL, serverResponse)
 546
 547     REST <- RESTService$new("token", "https://host/",
 548                             fakeHttp, FakeHttpParser$new(),
 549                             0, "https://webDavHost/")
 550
 551     returnResult <- REST$read("file", uuid, "text", 1024, 512)
 552
 553     expect_that(fakeHttp$URLIsProperlyConfigured, is_true())
 554     expect_that(fakeHttp$requestHeaderContainsAuthorizationField, is_true())
 555     expect_that(fakeHttp$requestHeaderContainsRangeField, is_true())
 556     expect_that(returnResult, equals("file content"))
 557 })
 558
 559 test_that("read raises exception if server response code is not between 200 and 300", {
 560
 561     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 562     response <- list()
 563     response$status_code <- 404
 564     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 565
 566     REST <- RESTService$new("token", "https://host/",
 567                             fakeHttp, HttpParser$new(),
 568                             0, "https://webDavHost/")
 569
 570     expect_that(REST$read("file", uuid),
 571                 throws_error("Server code: 404"))
 572 })
 573
 574 test_that("read raises exception if contentType is not valid", {
 575
 576     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 577     fakeHttp <- FakeHttpRequest$new()
 578
 579     REST <- RESTService$new("token", "https://host/",
 580                             fakeHttp, HttpParser$new(),
 581                             0, "https://webDavHost/")
 582
 583     expect_that(REST$read("file", uuid, "some invalid content type"),
 584                 throws_error("Invalid contentType. Please use text or raw."))
 585 })
 586
 587 test_that("read parses server response", {
 588
 589     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 590     fakeHttpParser <- FakeHttpParser$new()
 591     REST <- RESTService$new("token", "https://host/",
 592                             FakeHttpRequest$new(), fakeHttpParser,
 593                             0, "https://webDavHost/")
 594
 595     REST$read("file", uuid, "text", 1024, 512)
 596
 597     expect_that(fakeHttpParser$parserCallCount, equals(1))
 598 })
 599
 600 test_that("write calls REST service properly", {
 601
 602     fileContent <- "new file content"
 603     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 604     expectedURL <- "https://webDavHost/c=aaaaa-j7d0g-ccccccccccccccc/file"
 605     fakeHttp <- FakeHttpRequest$new(expectedURL)
 606
 607     REST <- RESTService$new("token", "https://host/",
 608                             fakeHttp, FakeHttpParser$new(),
 609                             0, "https://webDavHost/")
 610
 611     REST$write("file", uuid, fileContent, "text/html")
 612
 613     expect_that(fakeHttp$URLIsProperlyConfigured, is_true())
 614     expect_that(fakeHttp$requestBodyIsProvided, is_true())
 615     expect_that(fakeHttp$requestHeaderContainsAuthorizationField, is_true())
 616     expect_that(fakeHttp$requestHeaderContainsContentTypeField, is_true())
 617 })
 618
 619 test_that("write raises exception if server response code is not between 200 and 300", {
 620
 621     uuid <- "aaaaa-j7d0g-ccccccccccccccc"
 622     fileContent <- "new file content"
 623     response <- list()
 624     response$status_code <- 404
 625     fakeHttp <- FakeHttpRequest$new(serverResponse = response)
 626
 627     REST <- RESTService$new("token", "https://host/",
 628                             fakeHttp, HttpParser$new(),
 629                             0, "https://webDavHost/")
 630
 631     expect_that(REST$write("file", uuid, fileContent, "text/html"),
 632                 throws_error("Server code: 404"))
 633 })