services/api/test/unit/collection_test.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 require 'test_helper'
   6 require 'sweep_trashed_objects'
   7
   8 class CollectionTest < ActiveSupport::TestCase
   9   include DbCurrentTime
  10
  11   def create_collection name, enc=nil
  12     txt = ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:#{name}.txt\n"
  13     txt.force_encoding(enc) if enc
  14     return Collection.create(manifest_text: txt, name: name)
  15   end
  16
  17   test 'accept ASCII manifest_text' do
  18     act_as_system_user do
  19       c = create_collection 'foo', Encoding::US_ASCII
  20       assert c.valid?
  21     end
  22   end
  23
  24   test 'accept UTF-8 manifest_text' do
  25     act_as_system_user do
  26       c = create_collection "f\xc3\x98\xc3\x98", Encoding::UTF_8
  27       assert c.valid?
  28     end
  29   end
  30
  31   test 'refuse manifest_text with invalid UTF-8 byte sequence' do
  32     act_as_system_user do
  33       c = create_collection "f\xc8o", Encoding::UTF_8
  34       assert !c.valid?
  35       assert_equal [:manifest_text], c.errors.messages.keys
  36       assert_match(/UTF-8/, c.errors.messages[:manifest_text].first)
  37     end
  38   end
  39
  40   test 'refuse manifest_text with non-UTF-8 encoding' do
  41     act_as_system_user do
  42       c = create_collection "f\xc8o", Encoding::ASCII_8BIT
  43       assert !c.valid?
  44       assert_equal [:manifest_text], c.errors.messages.keys
  45       assert_match(/UTF-8/, c.errors.messages[:manifest_text].first)
  46     end
  47   end
  48
  49   [
  50     ". 0:0:foo.txt",
  51     ". d41d8cd98f00b204e9800998ecf8427e foo.txt",
  52     "d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt",
  53     ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt",
  54   ].each do |manifest_text|
  55     test "create collection with invalid manifest text #{manifest_text} and expect error" do
  56       act_as_system_user do
  57         c = Collection.create(manifest_text: manifest_text)
  58         assert !c.valid?
  59       end
  60     end
  61   end
  62
  63   [
  64     nil,
  65     "",
  66     ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n",
  67   ].each do |manifest_text|
  68     test "create collection with valid manifest text #{manifest_text.inspect} and expect success" do
  69       act_as_system_user do
  70         c = Collection.create(manifest_text: manifest_text)
  71         assert c.valid?
  72       end
  73     end
  74   end
  75
  76   [
  77     ". 0:0:foo.txt",
  78     ". d41d8cd98f00b204e9800998ecf8427e foo.txt",
  79     "d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt",
  80     ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt",
  81   ].each do |manifest_text|
  82     test "update collection with invalid manifest text #{manifest_text} and expect error" do
  83       act_as_system_user do
  84         c = create_collection 'foo', Encoding::US_ASCII
  85         assert c.valid?
  86
  87         c.update_attribute 'manifest_text', manifest_text
  88         assert !c.valid?
  89       end
  90     end
  91   end
  92
  93   [
  94     nil,
  95     "",
  96     ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n",
  97   ].each do |manifest_text|
  98     test "update collection with valid manifest text #{manifest_text.inspect} and expect success" do
  99       act_as_system_user do
 100         c = create_collection 'foo', Encoding::US_ASCII
 101         assert c.valid?
 102
 103         c.update_attribute 'manifest_text', manifest_text
 104         assert c.valid?
 105       end
 106     end
 107   end
 108
 109   test "auto-create version after idle setting" do
 110     Rails.configuration.collection_versioning = true
 111     Rails.configuration.preserve_version_if_idle = 600 # 10 minutes
 112     act_as_user users(:active) do
 113       # Set up initial collection
 114       c = create_collection 'foo', Encoding::US_ASCII
 115       assert c.valid?
 116       assert_equal 1, c.version
 117       assert_equal false, c.preserve_version
 118       # Make a versionable update, it shouldn't create a new version yet
 119       c.update_attributes!({'name' => 'bar'})
 120       c.reload
 121       assert_equal 'bar', c.name
 122       assert_equal 1, c.version
 123       # Update modified_at to trigger a version auto-creation
 124       fifteen_min_ago = Time.now - 15.minutes
 125       c.update_column('modified_at', fifteen_min_ago) # Update without validations/callbacks
 126       c.reload
 127       assert_equal fifteen_min_ago.to_i, c.modified_at.to_i
 128       c.update_attributes!({'name' => 'baz'})
 129       c.reload
 130       assert_equal 'baz', c.name
 131       assert_equal 2, c.version
 132       # Make another update, no new version should be created
 133       c.update_attributes!({'name' => 'foobar'})
 134       c.reload
 135       assert_equal 'foobar', c.name
 136       assert_equal 2, c.version
 137     end
 138   end
 139
 140   test "preserve_version=false assignment is ignored while being true and not producing a new version" do
 141     Rails.configuration.collection_versioning = true
 142     Rails.configuration.preserve_version_if_idle = 3600
 143     act_as_user users(:active) do
 144       # Set up initial collection
 145       c = create_collection 'foo', Encoding::US_ASCII
 146       assert c.valid?
 147       assert_equal 1, c.version
 148       assert_equal false, c.preserve_version
 149       # This update shouldn't produce a new version, as the idle time is not up
 150       c.update_attributes!({
 151         'name' => 'bar',
 152         'preserve_version' => true
 153       })
 154       c.reload
 155       assert_equal 1, c.version
 156       assert_equal 'bar', c.name
 157       assert_equal true, c.preserve_version
 158       # Make sure preserve_version is not disabled after being enabled, unless
 159       # a new version is created.
 160       c.update_attributes!({
 161         'preserve_version' => false,
 162         'replication_desired' => 2
 163       })
 164       c.reload
 165       assert_equal 1, c.version
 166       assert_equal 2, c.replication_desired
 167       assert_equal true, c.preserve_version
 168       c.update_attributes!({'name' => 'foobar'})
 169       c.reload
 170       assert_equal 2, c.version
 171       assert_equal false, c.preserve_version
 172       assert_equal 'foobar', c.name
 173     end
 174   end
 175
 176   test "uuid updates on current version make older versions update their pointers" do
 177     Rails.configuration.collection_versioning = true
 178     Rails.configuration.preserve_version_if_idle = 0
 179     act_as_system_user do
 180       # Set up initial collection
 181       c = create_collection 'foo', Encoding::US_ASCII
 182       assert c.valid?
 183       assert_equal 1, c.version
 184       # Make changes so that a new version is created
 185       c.update_attributes!({'name' => 'bar'})
 186       c.reload
 187       assert_equal 2, c.version
 188       assert_equal 2, Collection.where(current_version_uuid: c.uuid).count
 189       new_uuid = 'zzzzz-4zz18-somefakeuuidnow'
 190       assert_empty Collection.where(uuid: new_uuid)
 191       # Update UUID on current version, check that both collections point to it
 192       c.update_attributes!({'uuid' => new_uuid})
 193       c.reload
 194       assert_equal new_uuid, c.uuid
 195       assert_equal 2, Collection.where(current_version_uuid: new_uuid).count
 196     end
 197   end
 198
 199   test "older versions' modified_at indicate when they're created" do
 200     Rails.configuration.collection_versioning = true
 201     Rails.configuration.preserve_version_if_idle = 0
 202     act_as_user users(:active) do
 203       # Set up initial collection
 204       c = create_collection 'foo', Encoding::US_ASCII
 205       assert c.valid?
 206       # Make changes so that a new version is created
 207       c.update_attributes!({'name' => 'bar'})
 208       c.reload
 209       assert_equal 2, c.version
 210       # Get the old version
 211       c_old = Collection.where(current_version_uuid: c.uuid, version: 1).first
 212       assert_not_nil c_old
 213
 214       version_creation_datetime = c_old.modified_at.to_f
 215       assert_equal c.created_at.to_f, c_old.created_at.to_f
 216       # Current version is updated just a few milliseconds before the version is
 217       # saved on the database.
 218       assert_operator c.modified_at.to_f, :<, version_creation_datetime
 219
 220       # Make update on current version so old version get the attribute synced;
 221       # its modified_at should not change.
 222       new_replication = 3
 223       c.update_attributes!({'replication_desired' => new_replication})
 224       c.reload
 225       assert_equal new_replication, c.replication_desired
 226       c_old.reload
 227       assert_equal new_replication, c_old.replication_desired
 228       assert_equal version_creation_datetime, c_old.modified_at.to_f
 229       assert_operator c.modified_at.to_f, :>, c_old.modified_at.to_f
 230     end
 231   end
 232
 233   test "past versions should not be directly updatable" do
 234     Rails.configuration.collection_versioning = true
 235     Rails.configuration.preserve_version_if_idle = 0
 236     act_as_system_user do
 237       # Set up initial collection
 238       c = create_collection 'foo', Encoding::US_ASCII
 239       assert c.valid?
 240       # Make changes so that a new version is created
 241       c.update_attributes!({'name' => 'bar'})
 242       c.reload
 243       assert_equal 2, c.version
 244       # Get the old version
 245       c_old = Collection.where(current_version_uuid: c.uuid, version: 1).first
 246       assert_not_nil c_old
 247       # With collection versioning still being enabled, try to update
 248       c_old.name = 'this was foo'
 249       assert c_old.invalid?
 250       c_old.reload
 251       # Try to fool the validator attempting to make c_old to look like a
 252       # current version, it should also fail.
 253       c_old.current_version_uuid = c_old.uuid
 254       assert c_old.invalid?
 255       c_old.reload
 256       # Now disable collection versioning, it should behave the same way
 257       Rails.configuration.collection_versioning = false
 258       c_old.name = 'this was foo'
 259       assert c_old.invalid?
 260     end
 261   end
 262
 263   [
 264     ['owner_uuid', 'zzzzz-tpzed-d9tiejq69daie8f', 'zzzzz-tpzed-xurymjxw79nv3jz'],
 265     ['replication_desired', 2, 3],
 266     ['storage_classes_desired', ['hot'], ['archive']],
 267     ['is_trashed', true, false],
 268   ].each do |attr, first_val, second_val|
 269     test "sync #{attr} with older versions" do
 270       Rails.configuration.collection_versioning = true
 271       Rails.configuration.preserve_version_if_idle = 0
 272       act_as_system_user do
 273         # Set up initial collection
 274         c = create_collection 'foo', Encoding::US_ASCII
 275         assert c.valid?
 276         assert_equal 1, c.version
 277         assert_not_equal first_val, c.attributes[attr]
 278         # Make changes so that a new version is created and a synced field is
 279         # updated on both
 280         c.update_attributes!({'name' => 'bar', attr => first_val})
 281         c.reload
 282         assert_equal 2, c.version
 283         assert_equal first_val, c.attributes[attr]
 284         assert_equal 2, Collection.where(current_version_uuid: c.uuid).count
 285         assert_equal first_val, Collection.where(current_version_uuid: c.uuid, version: 1).first.attributes[attr]
 286         # Only make an update on the same synced field & check that the previously
 287         # created version also gets it.
 288         c.update_attributes!({attr => second_val})
 289         c.reload
 290         assert_equal 2, c.version
 291         assert_equal second_val, c.attributes[attr]
 292         assert_equal 2, Collection.where(current_version_uuid: c.uuid).count
 293         assert_equal second_val, Collection.where(current_version_uuid: c.uuid, version: 1).first.attributes[attr]
 294       end
 295     end
 296   end
 297
 298   [
 299     [false, 'name', 'bar', false],
 300     [false, 'description', 'The quick brown fox jumps over the lazy dog', false],
 301     [false, 'properties', {'new_version' => true}, false],
 302     [false, 'manifest_text', ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n", false],
 303     [true, 'name', 'bar', true],
 304     [true, 'description', 'The quick brown fox jumps over the lazy dog', true],
 305     [true, 'properties', {'new_version' => true}, true],
 306     [true, 'manifest_text', ". d41d8cd98f00b204e9800998ecf8427e 0:0:foo.txt\n", true],
 307     # Non-versionable attribute updates shouldn't create new versions
 308     [true, 'replication_desired', 5, false],
 309     [false, 'replication_desired', 5, false],
 310   ].each do |versioning, attr, val, new_version_expected|
 311     test "update #{attr} with versioning #{versioning ? '' : 'not '}enabled should #{new_version_expected ? '' : 'not '}create a new version" do
 312       Rails.configuration.collection_versioning = versioning
 313       Rails.configuration.preserve_version_if_idle = 0
 314       act_as_user users(:active) do
 315         # Create initial collection
 316         c = create_collection 'foo', Encoding::US_ASCII
 317         assert c.valid?
 318         assert_equal 'foo', c.name
 319
 320         # Check current version attributes
 321         assert_equal 1, c.version
 322         assert_equal c.uuid, c.current_version_uuid
 323
 324         # Update attribute and check if version number should be incremented
 325         old_value = c.attributes[attr]
 326         c.update_attributes!({attr => val})
 327         assert_equal new_version_expected, c.version == 2
 328         assert_equal val, c.attributes[attr]
 329
 330         if versioning && new_version_expected
 331           # Search for the snapshot & previous value
 332           assert_equal 2, Collection.where(current_version_uuid: c.uuid).count
 333           s = Collection.where(current_version_uuid: c.uuid, version: 1).first
 334           assert_not_nil s
 335           assert_equal old_value, s.attributes[attr]
 336         else
 337           # If versioning is disabled or no versionable attribute was updated,
 338           # only the current version should exist
 339           assert_equal 1, Collection.where(current_version_uuid: c.uuid).count
 340           assert_equal c, Collection.where(current_version_uuid: c.uuid).first
 341         end
 342       end
 343     end
 344   end
 345
 346   test 'current_version_uuid is ignored during update' do
 347     Rails.configuration.collection_versioning = true
 348     Rails.configuration.preserve_version_if_idle = 0
 349     act_as_user users(:active) do
 350       # Create 1st collection
 351       col1 = create_collection 'foo', Encoding::US_ASCII
 352       assert col1.valid?
 353       assert_equal 1, col1.version
 354
 355       # Create 2nd collection, update it so it becomes version:2
 356       # (to avoid unique index violation)
 357       col2 = create_collection 'bar', Encoding::US_ASCII
 358       assert col2.valid?
 359       assert_equal 1, col2.version
 360       col2.update_attributes({name: 'baz'})
 361       assert_equal 2, col2.version
 362
 363       # Try to make col2 a past version of col1. It shouldn't be possible
 364       col2.update_attributes({current_version_uuid: col1.uuid})
 365       assert col2.invalid?
 366       col2.reload
 367       assert_not_equal col1.uuid, col2.current_version_uuid
 368     end
 369   end
 370
 371   test 'with versioning enabled, simultaneous updates increment version correctly' do
 372     Rails.configuration.collection_versioning = true
 373     Rails.configuration.preserve_version_if_idle = 0
 374     act_as_user users(:active) do
 375       # Create initial collection
 376       col = create_collection 'foo', Encoding::US_ASCII
 377       assert col.valid?
 378       assert_equal 1, col.version
 379
 380       # Simulate simultaneous updates
 381       c1 = Collection.where(uuid: col.uuid).first
 382       assert_equal 1, c1.version
 383       c1.name = 'bar'
 384       c2 = Collection.where(uuid: col.uuid).first
 385       c2.description = 'foo collection'
 386       c1.save!
 387       assert_equal 1, c2.version
 388       # with_lock forces a reload, so this shouldn't produce an unique violation error
 389       c2.save!
 390       assert_equal 3, c2.version
 391       assert_equal 'foo collection', c2.description
 392     end
 393   end
 394
 395   test 'create and update collection and verify file_names' do
 396     act_as_system_user do
 397       c = create_collection 'foo', Encoding::US_ASCII
 398       assert c.valid?
 399       created_file_names = c.file_names
 400       assert created_file_names
 401       assert_match(/foo.txt/, c.file_names)
 402
 403       c.update_attribute 'manifest_text', ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:foo2.txt\n"
 404       assert_not_equal created_file_names, c.file_names
 405       assert_match(/foo2.txt/, c.file_names)
 406     end
 407   end
 408
 409   [
 410     [2**8, false],
 411     [2**18, true],
 412   ].each do |manifest_size, allow_truncate|
 413     test "create collection with manifest size #{manifest_size} with allow_truncate=#{allow_truncate},
 414           and not expect exceptions even on very large manifest texts" do
 415       # file_names has a max size, hence there will be no errors even on large manifests
 416       act_as_system_user do
 417         manifest_text = ''
 418         index = 0
 419         while manifest_text.length < manifest_size
 420           manifest_text += "./blurfl d41d8cd98f00b204e9800998ecf8427e+0 0:0:veryverylongfilename000000000000#{index}.txt\n"
 421           index += 1
 422         end
 423         manifest_text += "./laststreamname d41d8cd98f00b204e9800998ecf8427e+0 0:0:veryverylastfilename.txt\n"
 424         c = Collection.create(manifest_text: manifest_text)
 425
 426         assert c.valid?
 427         assert c.file_names
 428         assert_match(/veryverylongfilename0000000000001.txt/, c.file_names)
 429         assert_match(/veryverylongfilename0000000000002.txt/, c.file_names)
 430         if not allow_truncate
 431           assert_match(/veryverylastfilename/, c.file_names)
 432           assert_match(/laststreamname/, c.file_names)
 433         end
 434       end
 435     end
 436   end
 437
 438   test "full text search for collections" do
 439     # file_names column does not get populated when fixtures are loaded, hence setup test data
 440     act_as_system_user do
 441       Collection.create(manifest_text: ". acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:foo\n")
 442       Collection.create(manifest_text: ". 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar\n")
 443       Collection.create(manifest_text: ". 85877ca2d7e05498dd3d109baf2df106+95+A3a4e26a366ee7e4ed3e476ccf05354761be2e4ae@545a9920 0:95:file_in_subdir1\n./subdir2/subdir3 2bbc341c702df4d8f42ec31f16c10120+64+A315d7e7bad2ce937e711fc454fae2d1194d14d64@545a9920 0:32:file1.txt 32:32:file2.txt\n./subdir2/subdir3/subdir4 2bbc341c702df4d8f42ec31f16c10120+64+A315d7e7bad2ce937e711fc454fae2d1194d14d64@545a9920 0:32:file3.txt 32:32:file4.txt\n")
 444     end
 445
 446     [
 447       ['foo', true],
 448       ['foo bar', false],                     # no collection matching both
 449       ['foo&bar', false],                     # no collection matching both
 450       ['foo|bar', true],                      # works only no spaces between the words
 451       ['Gnu public', true],                   # both prefixes found, though not consecutively
 452       ['Gnu&public', true],                   # both prefixes found, though not consecutively
 453       ['file4', true],                        # prefix match
 454       ['file4.txt', true],                    # whole string match
 455       ['filex', false],                       # no such prefix
 456       ['subdir', true],                       # prefix matches
 457       ['subdir2', true],
 458       ['subdir2/', true],
 459       ['subdir2/subdir3', true],
 460       ['subdir2/subdir3/subdir4', true],
 461       ['subdir2 file4', true],                # look for both prefixes
 462       ['subdir4', false],                     # not a prefix match
 463     ].each do |search_filter, expect_results|
 464       search_filters = search_filter.split.each {|s| s.concat(':*')}.join('&')
 465       results = Collection.where("#{Collection.full_text_tsvector} @@ to_tsquery(?)",
 466                                  "#{search_filters}")
 467       if expect_results
 468         refute_empty results
 469       else
 470         assert_empty results
 471       end
 472     end
 473   end
 474
 475   test 'portable data hash with missing size hints' do
 476     [[". d41d8cd98f00b204e9800998ecf8427e+0+Bar 0:0:x\n",
 477       ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:x\n"],
 478      [". d41d8cd98f00b204e9800998ecf8427e+Foo 0:0:x\n",
 479       ". d41d8cd98f00b204e9800998ecf8427e 0:0:x\n"],
 480      [". d41d8cd98f00b204e9800998ecf8427e 0:0:x\n",
 481       ". d41d8cd98f00b204e9800998ecf8427e 0:0:x\n"],
 482     ].each do |unportable, portable|
 483       c = Collection.new(manifest_text: unportable)
 484       assert c.valid?
 485       assert_equal(Digest::MD5.hexdigest(portable)+"+#{portable.length}",
 486                    c.portable_data_hash)
 487     end
 488   end
 489
 490   pdhmanifest = ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:x\n"
 491   pdhmd5 = Digest::MD5.hexdigest pdhmanifest
 492   [[true, nil],
 493    [true, pdhmd5],
 494    [true, pdhmd5+'+12345'],
 495    [true, pdhmd5+'+'+pdhmanifest.length.to_s],
 496    [true, pdhmd5+'+12345+Foo'],
 497    [true, pdhmd5+'+Foo'],
 498    [false, Digest::MD5.hexdigest(pdhmanifest.strip)],
 499    [false, Digest::MD5.hexdigest(pdhmanifest.strip)+'+'+pdhmanifest.length.to_s],
 500    [false, pdhmd5[0..30]],
 501    [false, pdhmd5[0..30]+'z'],
 502    [false, pdhmd5[0..24]+'000000000'],
 503    [false, pdhmd5[0..24]+'000000000+0']].each do |isvalid, pdh|
 504     test "portable_data_hash #{pdh.inspect} valid? == #{isvalid}" do
 505       c = Collection.new manifest_text: pdhmanifest, portable_data_hash: pdh
 506       assert_equal isvalid, c.valid?, c.errors.full_messages.to_s
 507     end
 508   end
 509
 510   test "storage_classes_desired cannot be empty" do
 511     act_as_user users(:active) do
 512       c = collections(:collection_owned_by_active)
 513       c.update_attributes storage_classes_desired: ["hot"]
 514       assert_equal ["hot"], c.storage_classes_desired
 515       assert_raise ArvadosModel::InvalidStateTransitionError do
 516         c.update_attributes storage_classes_desired: []
 517       end
 518     end
 519   end
 520
 521   test "storage classes lists should only contain non-empty strings" do
 522     c = collections(:storage_classes_desired_default_unconfirmed)
 523     act_as_user users(:admin) do
 524       assert c.update_attributes(storage_classes_desired: ["default", "a_string"],
 525                                  storage_classes_confirmed: ["another_string"])
 526       [
 527         ["storage_classes_desired", ["default", 42]],
 528         ["storage_classes_confirmed", [{the_answer: 42}]],
 529         ["storage_classes_desired", ["default", ""]],
 530         ["storage_classes_confirmed", [""]],
 531       ].each do |attr, val|
 532         assert_raise ArvadosModel::InvalidStateTransitionError do
 533           assert c.update_attributes({attr => val})
 534         end
 535       end
 536     end
 537   end
 538
 539   test "storage_classes_confirmed* can be set by admin user" do
 540     c = collections(:storage_classes_desired_default_unconfirmed)
 541     act_as_user users(:admin) do
 542       assert c.update_attributes(storage_classes_confirmed: ["default"],
 543                                  storage_classes_confirmed_at: Time.now)
 544     end
 545   end
 546
 547   test "storage_classes_confirmed* cannot be set by non-admin user" do
 548     act_as_user users(:active) do
 549       c = collections(:storage_classes_desired_default_unconfirmed)
 550       # Cannot set just one at a time.
 551       assert_raise ArvadosModel::PermissionDeniedError do
 552         c.update_attributes storage_classes_confirmed: ["default"]
 553       end
 554       c.reload
 555       assert_raise ArvadosModel::PermissionDeniedError do
 556         c.update_attributes storage_classes_confirmed_at: Time.now
 557       end
 558       # Cannot set bot at once, either.
 559       c.reload
 560       assert_raise ArvadosModel::PermissionDeniedError do
 561         assert c.update_attributes(storage_classes_confirmed: ["default"],
 562                                    storage_classes_confirmed_at: Time.now)
 563       end
 564     end
 565   end
 566
 567   test "storage_classes_confirmed* can be cleared (but only together) by non-admin user" do
 568     act_as_user users(:active) do
 569       c = collections(:storage_classes_desired_default_confirmed_default)
 570       # Cannot clear just one at a time.
 571       assert_raise ArvadosModel::PermissionDeniedError do
 572         c.update_attributes storage_classes_confirmed: []
 573       end
 574       c.reload
 575       assert_raise ArvadosModel::PermissionDeniedError do
 576         c.update_attributes storage_classes_confirmed_at: nil
 577       end
 578       # Can clear both at once.
 579       c.reload
 580       assert c.update_attributes(storage_classes_confirmed: [],
 581                                  storage_classes_confirmed_at: nil)
 582     end
 583   end
 584
 585   [0, 2, 4, nil].each do |ask|
 586     test "set replication_desired to #{ask.inspect}" do
 587       Rails.configuration.default_collection_replication = 2
 588       act_as_user users(:active) do
 589         c = collections(:replication_undesired_unconfirmed)
 590         c.update_attributes replication_desired: ask
 591         assert_equal ask, c.replication_desired
 592       end
 593     end
 594   end
 595
 596   test "replication_confirmed* can be set by admin user" do
 597     c = collections(:replication_desired_2_unconfirmed)
 598     act_as_user users(:admin) do
 599       assert c.update_attributes(replication_confirmed: 2,
 600                                  replication_confirmed_at: Time.now)
 601     end
 602   end
 603
 604   test "replication_confirmed* cannot be set by non-admin user" do
 605     act_as_user users(:active) do
 606       c = collections(:replication_desired_2_unconfirmed)
 607       # Cannot set just one at a time.
 608       assert_raise ArvadosModel::PermissionDeniedError do
 609         c.update_attributes replication_confirmed: 1
 610       end
 611       assert_raise ArvadosModel::PermissionDeniedError do
 612         c.update_attributes replication_confirmed_at: Time.now
 613       end
 614       # Cannot set both at once, either.
 615       assert_raise ArvadosModel::PermissionDeniedError do
 616         c.update_attributes(replication_confirmed: 1,
 617                             replication_confirmed_at: Time.now)
 618       end
 619     end
 620   end
 621
 622   test "replication_confirmed* can be cleared (but only together) by non-admin user" do
 623     act_as_user users(:active) do
 624       c = collections(:replication_desired_2_confirmed_2)
 625       # Cannot clear just one at a time.
 626       assert_raise ArvadosModel::PermissionDeniedError do
 627         c.update_attributes replication_confirmed: nil
 628       end
 629       c.reload
 630       assert_raise ArvadosModel::PermissionDeniedError do
 631         c.update_attributes replication_confirmed_at: nil
 632       end
 633       # Can clear both at once.
 634       c.reload
 635       assert c.update_attributes(replication_confirmed: nil,
 636                                  replication_confirmed_at: nil)
 637     end
 638   end
 639
 640   test "clear replication_confirmed* when introducing a new block in manifest" do
 641     c = collections(:replication_desired_2_confirmed_2)
 642     act_as_user users(:active) do
 643       assert c.update_attributes(manifest_text: collections(:user_agreement).signed_manifest_text)
 644       assert_nil c.replication_confirmed
 645       assert_nil c.replication_confirmed_at
 646     end
 647   end
 648
 649   test "don't clear replication_confirmed* when just renaming a file" do
 650     c = collections(:replication_desired_2_confirmed_2)
 651     act_as_user users(:active) do
 652       new_manifest = c.signed_manifest_text.sub(':bar', ':foo')
 653       assert c.update_attributes(manifest_text: new_manifest)
 654       assert_equal 2, c.replication_confirmed
 655       assert_not_nil c.replication_confirmed_at
 656     end
 657   end
 658
 659   test "don't clear replication_confirmed* when just deleting a data block" do
 660     c = collections(:replication_desired_2_confirmed_2)
 661     act_as_user users(:active) do
 662       new_manifest = c.signed_manifest_text
 663       new_manifest.sub!(/ \S+:bar/, '')
 664       new_manifest.sub!(/ acbd\S+/, '')
 665
 666       # Confirm that we did just remove a block from the manifest (if
 667       # not, this test would pass without testing the relevant case):
 668       assert_operator new_manifest.length+40, :<, c.signed_manifest_text.length
 669
 670       assert c.update_attributes(manifest_text: new_manifest)
 671       assert_equal 2, c.replication_confirmed
 672       assert_not_nil c.replication_confirmed_at
 673     end
 674   end
 675
 676   test 'signature expiry does not exceed trash_at' do
 677     act_as_user users(:active) do
 678       t0 = db_current_time
 679       c = Collection.create!(manifest_text: ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:x\n", name: 'foo')
 680       c.update_attributes! trash_at: (t0 + 1.hours)
 681       c.reload
 682       sig_exp = /\+A[0-9a-f]{40}\@([0-9]+)/.match(c.signed_manifest_text)[1].to_i
 683       assert_operator sig_exp.to_i, :<=, (t0 + 1.hours).to_i
 684     end
 685   end
 686
 687   test 'far-future expiry date cannot be used to circumvent configured permission ttl' do
 688     act_as_user users(:active) do
 689       c = Collection.create!(manifest_text: ". d41d8cd98f00b204e9800998ecf8427e+0 0:0:x\n",
 690                              name: 'foo',
 691                              trash_at: db_current_time + 1.years)
 692       sig_exp = /\+A[0-9a-f]{40}\@([0-9]+)/.match(c.signed_manifest_text)[1].to_i
 693       expect_max_sig_exp = db_current_time.to_i + Rails.configuration.blob_signature_ttl
 694       assert_operator c.trash_at.to_i, :>, expect_max_sig_exp
 695       assert_operator sig_exp.to_i, :<=, expect_max_sig_exp
 696     end
 697   end
 698
 699   test "create collection with properties" do
 700     act_as_system_user do
 701       c = Collection.create(manifest_text: ". acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:foo\n",
 702                             properties: {'property_1' => 'value_1'})
 703       assert c.valid?
 704       assert_equal 'value_1', c.properties['property_1']
 705     end
 706   end
 707
 708   test 'create, delete, recreate collection with same name and owner' do
 709     act_as_user users(:active) do
 710       # create collection with name
 711       c = Collection.create(manifest_text: '',
 712                             name: "test collection name")
 713       assert c.valid?
 714       uuid = c.uuid
 715
 716       c = Collection.readable_by(current_user).where(uuid: uuid)
 717       assert_not_empty c, 'Should be able to find live collection'
 718
 719       # mark collection as expired
 720       c.first.update_attributes!(trash_at: Time.new.strftime("%Y-%m-%d"))
 721       c = Collection.readable_by(current_user).where(uuid: uuid)
 722       assert_empty c, 'Should not be able to find expired collection'
 723
 724       # recreate collection with the same name
 725       c = Collection.create(manifest_text: '',
 726                             name: "test collection name")
 727       assert c.valid?
 728     end
 729   end
 730
 731   test 'trash_at cannot be set too far in the past' do
 732     act_as_user users(:active) do
 733       t0 = db_current_time
 734       c = Collection.create!(manifest_text: '', name: 'foo')
 735       c.update_attributes! trash_at: (t0 - 2.weeks)
 736       c.reload
 737       assert_operator c.trash_at, :>, t0
 738     end
 739   end
 740
 741   now = Time.now
 742   [['trash-to-delete interval negative',
 743     :collection_owned_by_active,
 744     {trash_at: now+2.weeks, delete_at: now},
 745     {state: :invalid}],
 746    ['now-to-delete interval short',
 747     :collection_owned_by_active,
 748     {trash_at: now+3.days, delete_at: now+7.days},
 749     {state: :trash_future}],
 750    ['now-to-delete interval short, trash=delete',
 751     :collection_owned_by_active,
 752     {trash_at: now+3.days, delete_at: now+3.days},
 753     {state: :trash_future}],
 754    ['trash-to-delete interval ok',
 755     :collection_owned_by_active,
 756     {trash_at: now, delete_at: now+15.days},
 757     {state: :trash_now}],
 758    ['trash-to-delete interval short, but far enough in future',
 759     :collection_owned_by_active,
 760     {trash_at: now+13.days, delete_at: now+15.days},
 761     {state: :trash_future}],
 762    ['trash by setting is_trashed bool',
 763     :collection_owned_by_active,
 764     {is_trashed: true},
 765     {state: :trash_now}],
 766    ['trash in future by setting just trash_at',
 767     :collection_owned_by_active,
 768     {trash_at: now+1.week},
 769     {state: :trash_future}],
 770    ['trash in future by setting trash_at and delete_at',
 771     :collection_owned_by_active,
 772     {trash_at: now+1.week, delete_at: now+4.weeks},
 773     {state: :trash_future}],
 774    ['untrash by clearing is_trashed bool',
 775     :expired_collection,
 776     {is_trashed: false},
 777     {state: :not_trash}],
 778   ].each do |test_name, fixture_name, updates, expect|
 779     test test_name do
 780       act_as_user users(:active) do
 781         min_exp = (db_current_time +
 782                    Rails.configuration.blob_signature_ttl.seconds)
 783         if fixture_name == :expired_collection
 784           # Fixture-finder shorthand doesn't find trashed collections
 785           # because they're not in the default scope.
 786           c = Collection.find_by_uuid('zzzzz-4zz18-mto52zx1s7sn3ih')
 787         else
 788           c = collections(fixture_name)
 789         end
 790         updates_ok = c.update_attributes(updates)
 791         expect_valid = expect[:state] != :invalid
 792         assert_equal expect_valid, updates_ok, c.errors.full_messages.to_s
 793         case expect[:state]
 794         when :invalid
 795           refute c.valid?
 796         when :trash_now
 797           assert c.is_trashed
 798           assert_not_nil c.trash_at
 799           assert_operator c.trash_at, :<=, db_current_time
 800           assert_not_nil c.delete_at
 801           assert_operator c.delete_at, :>=, min_exp
 802         when :trash_future
 803           refute c.is_trashed
 804           assert_not_nil c.trash_at
 805           assert_operator c.trash_at, :>, db_current_time
 806           assert_not_nil c.delete_at
 807           assert_operator c.delete_at, :>=, c.trash_at
 808           # Currently this minimum interval is needed to prevent early
 809           # garbage collection:
 810           assert_operator c.delete_at, :>=, min_exp
 811         when :not_trash
 812           refute c.is_trashed
 813           assert_nil c.trash_at
 814           assert_nil c.delete_at
 815         else
 816           raise "bad expect[:state]==#{expect[:state].inspect} in test case"
 817         end
 818       end
 819     end
 820   end
 821
 822   test 'default trash interval > blob signature ttl' do
 823     Rails.configuration.default_trash_lifetime = 86400 * 21 # 3 weeks
 824     start = db_current_time
 825     act_as_user users(:active) do
 826       c = Collection.create!(manifest_text: '', name: 'foo')
 827       c.update_attributes!(trash_at: start + 86400.seconds)
 828       assert_operator c.delete_at, :>=, start + (86400*22).seconds
 829       assert_operator c.delete_at, :<, start + (86400*22 + 30).seconds
 830       c.destroy
 831
 832       c = Collection.create!(manifest_text: '', name: 'foo')
 833       c.update_attributes!(is_trashed: true)
 834       assert_operator c.delete_at, :>=, start + (86400*21).seconds
 835     end
 836   end
 837
 838   test "find_all_for_docker_image resolves names that look like hashes" do
 839     coll_list = Collection.
 840       find_all_for_docker_image('a' * 64, nil, [users(:active)])
 841     coll_uuids = coll_list.map(&:uuid)
 842     assert_includes(coll_uuids, collections(:docker_image).uuid)
 843   end
 844
 845   test "move collections to trash in SweepTrashedObjects" do
 846     c = collections(:trashed_on_next_sweep)
 847     refute_empty Collection.where('uuid=? and is_trashed=false', c.uuid)
 848     assert_raises(ActiveRecord::RecordNotUnique) do
 849       act_as_user users(:active) do
 850         Collection.create!(owner_uuid: c.owner_uuid,
 851                            name: c.name)
 852       end
 853     end
 854     SweepTrashedObjects.sweep_now
 855     c = Collection.where('uuid=? and is_trashed=true', c.uuid).first
 856     assert c
 857     act_as_user users(:active) do
 858       assert Collection.create!(owner_uuid: c.owner_uuid,
 859                                 name: c.name)
 860     end
 861   end
 862
 863   test "delete collections in SweepTrashedObjects" do
 864     uuid = 'zzzzz-4zz18-3u1p5umicfpqszp' # deleted_on_next_sweep
 865     assert_not_empty Collection.where(uuid: uuid)
 866     SweepTrashedObjects.sweep_now
 867     assert_empty Collection.where(uuid: uuid)
 868   end
 869
 870   test "delete referring links in SweepTrashedObjects" do
 871     uuid = collections(:trashed_on_next_sweep).uuid
 872     act_as_system_user do
 873       Link.create!(head_uuid: uuid,
 874                    tail_uuid: system_user_uuid,
 875                    link_class: 'whatever',
 876                    name: 'something')
 877     end
 878     past = db_current_time
 879     Collection.where(uuid: uuid).
 880       update_all(is_trashed: true, trash_at: past, delete_at: past)
 881     assert_not_empty Collection.where(uuid: uuid)
 882     SweepTrashedObjects.sweep_now
 883     assert_empty Collection.where(uuid: uuid)
 884   end
 885 end