services/api/test/functional/arvados/v1/collections_controller_test.rb

   1 require 'test_helper'
   2
   3 class Arvados::V1::CollectionsControllerTest < ActionController::TestCase
   4
   5   test "should get index" do
   6     authorize_with :active
   7     get :index
   8     assert_response :success
   9     assert_not_nil assigns(:objects)
  10   end
  11
  12   [0,1,2].each do |limit|
  13     test "get index with limit=#{limit}" do
  14       authorize_with :active
  15       get :index, limit: limit
  16       assert_response :success
  17       assert_equal limit, assigns(:objects).count
  18       resp = JSON.parse(@response.body)
  19       assert_equal limit, resp['limit']
  20     end
  21   end
  22
  23   test "items.count == items_available" do
  24     authorize_with :active
  25     get :index, limit: 100000
  26     assert_response :success
  27     resp = JSON.parse(@response.body)
  28     assert_equal resp['items_available'], assigns(:objects).length
  29     assert_equal resp['items_available'], resp['items'].count
  30     unique_uuids = resp['items'].collect { |i| i['uuid'] }.compact.uniq
  31     assert_equal unique_uuids.count, resp['items'].count
  32   end
  33
  34   test "get index with limit=2 offset=99999" do
  35     # Assume there are not that many test fixtures.
  36     authorize_with :active
  37     get :index, limit: 2, offset: 99999
  38     assert_response :success
  39     assert_equal 0, assigns(:objects).count
  40     resp = JSON.parse(@response.body)
  41     assert_equal 2, resp['limit']
  42     assert_equal 99999, resp['offset']
  43   end
  44
  45   test "should create" do
  46     authorize_with :active
  47     test_collection = {
  48       manifest_text: <<-EOS
  49 . d41d8cd98f00b204e9800998ecf8427e+0 0:0:foo.txt
  50 . acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:bar.txt
  51 . acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:bar.txt
  52 ./baz acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:bar.txt
  53 EOS
  54     }
  55     test_collection[:uuid] =
  56       Digest::MD5.hexdigest(test_collection[:manifest_text]) +
  57       '+' +
  58       test_collection[:manifest_text].length.to_s
  59     post :create, {
  60       collection: test_collection
  61     }
  62     assert_response :success
  63     assert_nil assigns(:objects)
  64
  65     get :show, {
  66       id: test_collection[:uuid]
  67     }
  68     assert_response :success
  69     assert_not_nil assigns(:object)
  70     resp = JSON.parse(@response.body)
  71     assert_equal test_collection[:uuid], resp['uuid']
  72     assert_equal test_collection[:manifest_text], resp['manifest_text']
  73     assert_equal 9, resp['data_size']
  74     assert_equal [['.', 'foo.txt', 0],
  75                   ['.', 'bar.txt', 6],
  76                   ['./baz', 'bar.txt', 3]], resp['files']
  77   end
  78
  79   test "list of files is correct for empty manifest" do
  80     authorize_with :active
  81     test_collection = {
  82       manifest_text: "",
  83       uuid: "d41d8cd98f00b204e9800998ecf8427e+0"
  84     }
  85     post :create, {
  86       collection: test_collection
  87     }
  88     assert_response :success
  89
  90     get :show, {
  91       id: "d41d8cd98f00b204e9800998ecf8427e+0"
  92     }
  93     assert_response :success
  94     resp = JSON.parse(@response.body)
  95     assert_equal [], resp['files']
  96   end
  97
  98   test "create with owner_uuid set to owned group" do
  99     authorize_with :active
 100     manifest_text = ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n"
 101     post :create, {
 102       collection: {
 103         owner_uuid: 'zzzzz-j7d0g-rew6elm53kancon',
 104         manifest_text: manifest_text,
 105         uuid: "d30fe8ae534397864cb96c544f4cf102"
 106       }
 107     }
 108     assert_response :success
 109     resp = JSON.parse(@response.body)
 110     assert_equal 'zzzzz-tpzed-000000000000000', resp['owner_uuid']
 111   end
 112
 113   test "create with owner_uuid set to group i can_manage" do
 114     authorize_with :active
 115     manifest_text = ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n"
 116     post :create, {
 117       collection: {
 118         owner_uuid: 'zzzzz-j7d0g-8ulrifv67tve5sx',
 119         manifest_text: manifest_text,
 120         uuid: "d30fe8ae534397864cb96c544f4cf102"
 121       }
 122     }
 123     assert_response :success
 124     resp = JSON.parse(@response.body)
 125     assert_equal 'zzzzz-tpzed-000000000000000', resp['owner_uuid']
 126   end
 127
 128   test "create with owner_uuid set to group with no can_manage permission" do
 129     authorize_with :active
 130     manifest_text = ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n"
 131     post :create, {
 132       collection: {
 133         owner_uuid: 'zzzzz-j7d0g-it30l961gq3t0oi',
 134         manifest_text: manifest_text,
 135         uuid: "d30fe8ae534397864cb96c544f4cf102"
 136       }
 137     }
 138     assert_response 403
 139   end
 140
 141   test "admin create with owner_uuid set to group with no permission" do
 142     authorize_with :admin
 143     manifest_text = ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n"
 144     post :create, {
 145       collection: {
 146         owner_uuid: 'zzzzz-j7d0g-it30l961gq3t0oi',
 147         manifest_text: manifest_text,
 148         uuid: "d30fe8ae534397864cb96c544f4cf102"
 149       }
 150     }
 151     assert_response :success
 152   end
 153
 154   test "should create with collection passed as json" do
 155     authorize_with :active
 156     post :create, {
 157       collection: <<-EOS
 158       {
 159         "manifest_text":". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n",\
 160         "uuid":"d30fe8ae534397864cb96c544f4cf102"\
 161       }
 162       EOS
 163     }
 164     assert_response :success
 165   end
 166
 167   test "should fail to create with checksum mismatch" do
 168     authorize_with :active
 169     post :create, {
 170       collection: <<-EOS
 171       {
 172         "manifest_text":". d41d8cd98f00b204e9800998ecf8427e 0:0:bar.txt\n",\
 173         "uuid":"d30fe8ae534397864cb96c544f4cf102"\
 174       }
 175       EOS
 176     }
 177     assert_response 422
 178   end
 179
 180   test "collection UUID is normalized when created" do
 181     authorize_with :active
 182     post :create, {
 183       collection: {
 184         manifest_text: ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n",
 185         uuid: "d30fe8ae534397864cb96c544f4cf102+47+Khint+Xhint+Zhint"
 186       }
 187     }
 188     assert_response :success
 189     assert_not_nil assigns(:object)
 190     resp = JSON.parse(@response.body)
 191     assert_equal "d30fe8ae534397864cb96c544f4cf102+47", resp['uuid']
 192   end
 193
 194   test "get full provenance for baz file" do
 195     authorize_with :active
 196     get :provenance, id: 'ea10d51bcf88862dbcc36eb292017dfd+45'
 197     assert_response :success
 198     resp = JSON.parse(@response.body)
 199     assert_not_nil resp['ea10d51bcf88862dbcc36eb292017dfd+45'] # baz
 200     assert_not_nil resp['fa7aeb5140e2848d39b416daeef4ffc5+45'] # bar
 201     assert_not_nil resp['1f4b0bc7583c2a7f9102c395f4ffc5e3+45'] # foo
 202     assert_not_nil resp['zzzzz-8i9sb-cjs4pklxxjykyuq'] # bar->baz
 203     assert_not_nil resp['zzzzz-8i9sb-aceg2bnq7jt7kon'] # foo->bar
 204   end
 205
 206   test "get no provenance for foo file" do
 207     # spectator user cannot even see baz collection
 208     authorize_with :spectator
 209     get :provenance, id: '1f4b0bc7583c2a7f9102c395f4ffc5e3+45'
 210     assert_response 404
 211   end
 212
 213   test "get partial provenance for baz file" do
 214     # spectator user can see bar->baz job, but not foo->bar job
 215     authorize_with :spectator
 216     get :provenance, id: 'ea10d51bcf88862dbcc36eb292017dfd+45'
 217     assert_response :success
 218     resp = JSON.parse(@response.body)
 219     assert_not_nil resp['ea10d51bcf88862dbcc36eb292017dfd+45'] # baz
 220     assert_not_nil resp['fa7aeb5140e2848d39b416daeef4ffc5+45'] # bar
 221     assert_not_nil resp['zzzzz-8i9sb-cjs4pklxxjykyuq']     # bar->baz
 222     assert_nil resp['zzzzz-8i9sb-aceg2bnq7jt7kon']         # foo->bar
 223     assert_nil resp['1f4b0bc7583c2a7f9102c395f4ffc5e3+45'] # foo
 224   end
 225
 226   test "search collections with 'any' operator" do
 227     authorize_with :active
 228     get :index, {
 229       where: { any: ['contains', '7f9102c395f4ffc5e3'] }
 230     }
 231     assert_response :success
 232     found = assigns(:objects).collect(&:uuid)
 233     assert_equal 1, found.count
 234     assert_equal true, !!found.index('1f4b0bc7583c2a7f9102c395f4ffc5e3+45')
 235   end
 236
 237   test "create collection with signed manifest" do
 238     authorize_with :active
 239     locators = %w(
 240       d41d8cd98f00b204e9800998ecf8427e+0
 241       acbd18db4cc2f85cedef654fccc4a4d8+3
 242       ea10d51bcf88862dbcc36eb292017dfd+45)
 243
 244     unsigned_manifest = locators.map { |loc|
 245       ". " + loc + " 0:0:foo.txt\n"
 246     }.join()
 247     manifest_uuid = Digest::MD5.hexdigest(unsigned_manifest) +
 248       '+' +
 249       unsigned_manifest.length.to_s
 250
 251     # build a manifest with both signed and unsigned locators.
 252     # TODO(twp): in phase 4, all locators will need to be signed, so
 253     # this test should break and will need to be rewritten. Issue #2755.
 254     signing_opts = {
 255       key: Rails.configuration.blob_signing_key,
 256       api_token: api_token(:active),
 257     }
 258     signed_manifest =
 259       ". " + locators[0] + " 0:0:foo.txt\n" +
 260       ". " + Blob.sign_locator(locators[1], signing_opts) + " 0:0:foo.txt\n" +
 261       ". " + Blob.sign_locator(locators[2], signing_opts) + " 0:0:foo.txt\n"
 262
 263     post :create, {
 264       collection: {
 265         manifest_text: signed_manifest,
 266         uuid: manifest_uuid,
 267       }
 268     }
 269     assert_response :success
 270     assert_not_nil assigns(:object)
 271     resp = JSON.parse(@response.body)
 272     assert_equal manifest_uuid, resp['uuid']
 273     assert_equal 48, resp['data_size']
 274     # All of the locators in the output must be signed.
 275     resp['manifest_text'].lines.each do |entry|
 276       m = /([[:xdigit:]]{32}\+\S+)/.match(entry)
 277       if m
 278         assert Blob.verify_signature m[0], signing_opts
 279       end
 280     end
 281   end
 282
 283   test "create collection with signed manifest and explicit TTL" do
 284     authorize_with :active
 285     locators = %w(
 286       d41d8cd98f00b204e9800998ecf8427e+0
 287       acbd18db4cc2f85cedef654fccc4a4d8+3
 288       ea10d51bcf88862dbcc36eb292017dfd+45)
 289
 290     unsigned_manifest = locators.map { |loc|
 291       ". " + loc + " 0:0:foo.txt\n"
 292     }.join()
 293     manifest_uuid = Digest::MD5.hexdigest(unsigned_manifest) +
 294       '+' +
 295       unsigned_manifest.length.to_s
 296
 297     # build a manifest with both signed and unsigned locators.
 298     # TODO(twp): in phase 4, all locators will need to be signed, so
 299     # this test should break and will need to be rewritten. Issue #2755.
 300     signing_opts = {
 301       key: Rails.configuration.blob_signing_key,
 302       api_token: api_token(:active),
 303       ttl: 3600   # 1 hour
 304     }
 305     signed_manifest =
 306       ". " + locators[0] + " 0:0:foo.txt\n" +
 307       ". " + Blob.sign_locator(locators[1], signing_opts) + " 0:0:foo.txt\n" +
 308       ". " + Blob.sign_locator(locators[2], signing_opts) + " 0:0:foo.txt\n"
 309
 310     post :create, {
 311       collection: {
 312         manifest_text: signed_manifest,
 313         uuid: manifest_uuid,
 314       }
 315     }
 316     assert_response :success
 317     assert_not_nil assigns(:object)
 318     resp = JSON.parse(@response.body)
 319     assert_equal manifest_uuid, resp['uuid']
 320     assert_equal 48, resp['data_size']
 321     # All of the locators in the output must be signed.
 322     resp['manifest_text'].lines.each do |entry|
 323       m = /([[:xdigit:]]{32}\+\S+)/.match(entry)
 324       if m
 325         assert Blob.verify_signature m[0], signing_opts
 326       end
 327     end
 328   end
 329
 330   test "create fails with invalid signature" do
 331     authorize_with :active
 332     signing_opts = {
 333       key: Rails.configuration.blob_signing_key,
 334       api_token: api_token(:active),
 335     }
 336
 337     # Generate a locator with a bad signature.
 338     unsigned_locator = "d41d8cd98f00b204e9800998ecf8427e+0"
 339     bad_locator = unsigned_locator + "+Affffffff@ffffffff"
 340     assert !Blob.verify_signature(bad_locator, signing_opts)
 341
 342     # Creating a collection with this locator should
 343     # produce 403 Permission denied.
 344     unsigned_manifest = ". #{unsigned_locator} 0:0:foo.txt\n"
 345     manifest_uuid = Digest::MD5.hexdigest(unsigned_manifest) +
 346       '+' +
 347       unsigned_manifest.length.to_s
 348
 349     bad_manifest = ". #{bad_locator} 0:0:foo.txt\n"
 350     post :create, {
 351       collection: {
 352         manifest_text: bad_manifest,
 353         uuid: manifest_uuid
 354       }
 355     }
 356
 357     assert_response 403
 358   end
 359
 360   test "create fails with uuid of signed manifest" do
 361     authorize_with :active
 362     signing_opts = {
 363       key: Rails.configuration.blob_signing_key,
 364       api_token: api_token(:active),
 365     }
 366
 367     unsigned_locator = "d41d8cd98f00b204e9800998ecf8427e+0"
 368     signed_locator = Blob.sign_locator(unsigned_locator, signing_opts)
 369     signed_manifest = ". #{signed_locator} 0:0:foo.txt\n"
 370     manifest_uuid = Digest::MD5.hexdigest(signed_manifest) +
 371       '+' +
 372       signed_manifest.length.to_s
 373
 374     post :create, {
 375       collection: {
 376         manifest_text: signed_manifest,
 377         uuid: manifest_uuid
 378       }
 379     }
 380
 381     assert_response 422
 382   end
 383
 384   test "multiple locators per line" do
 385     authorize_with :active
 386     locators = %w(
 387       d41d8cd98f00b204e9800998ecf8427e+0
 388       acbd18db4cc2f85cedef654fccc4a4d8+3
 389       ea10d51bcf88862dbcc36eb292017dfd+45)
 390
 391     manifest_text = [".", *locators, "0:0:foo.txt\n"].join(" ")
 392     manifest_uuid = Digest::MD5.hexdigest(manifest_text) +
 393       '+' +
 394       manifest_text.length.to_s
 395
 396     post :create, {
 397       collection: {
 398         manifest_text: manifest_text,
 399         uuid: manifest_uuid,
 400       }
 401     }
 402     assert_response :success
 403     assert_not_nil assigns(:object)
 404     resp = JSON.parse(@response.body)
 405     assert_equal manifest_uuid, resp['uuid']
 406     assert_equal 48, resp['data_size']
 407     assert_equal resp['manifest_text'], manifest_text
 408   end
 409
 410   test "multiple signed locators per line" do
 411     authorize_with :active
 412     locators = %w(
 413       d41d8cd98f00b204e9800998ecf8427e+0
 414       acbd18db4cc2f85cedef654fccc4a4d8+3
 415       ea10d51bcf88862dbcc36eb292017dfd+45)
 416
 417     signing_opts = {
 418       key: Rails.configuration.blob_signing_key,
 419       api_token: api_token(:active),
 420     }
 421
 422     unsigned_manifest = [".", *locators, "0:0:foo.txt\n"].join(" ")
 423     manifest_uuid = Digest::MD5.hexdigest(unsigned_manifest) +
 424       '+' +
 425       unsigned_manifest.length.to_s
 426
 427     signed_locators = locators.map { |loc| Blob.sign_locator loc, signing_opts }
 428     signed_manifest = [".", *signed_locators, "0:0:foo.txt\n"].join(" ")
 429
 430     post :create, {
 431       collection: {
 432         manifest_text: signed_manifest,
 433         uuid: manifest_uuid,
 434       }
 435     }
 436     assert_response :success
 437     assert_not_nil assigns(:object)
 438     resp = JSON.parse(@response.body)
 439     assert_equal manifest_uuid, resp['uuid']
 440     assert_equal 48, resp['data_size']
 441     # All of the locators in the output must be signed.
 442     # Each line is of the form "path locator locator ... 0:0:file.txt"
 443     # entry.split[1..-2] will yield just the tokens in the middle of the line
 444     returned_locator_count = 0
 445     resp['manifest_text'].lines.each do |entry|
 446       entry.split[1..-2].each do |tok|
 447         returned_locator_count += 1
 448         assert Blob.verify_signature tok, signing_opts
 449       end
 450     end
 451     assert_equal locators.count, returned_locator_count
 452   end
 453 end