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

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