sdk/ruby/test/test_collection.rb

   1 require "arvados/collection"
   2 require "minitest/autorun"
   3 require "sdk_fixtures"
   4
   5 class CollectionTest < Minitest::Test
   6   include SDKFixtures
   7
   8   TWO_BY_TWO_BLOCKS = SDKFixtures.random_blocks(2, 9)
   9   TWO_BY_TWO_MANIFEST_A =
  10     [". #{TWO_BY_TWO_BLOCKS.first} 0:5:f1 5:4:f2\n",
  11      "./s1 #{TWO_BY_TWO_BLOCKS.last} 0:5:f1 5:4:f3\n"]
  12   TWO_BY_TWO_MANIFEST_S = TWO_BY_TWO_MANIFEST_A.join("")
  13
  14   ### .new
  15
  16   def test_empty_construction
  17     coll = Arv::Collection.new
  18     assert_equal("", coll.manifest_text)
  19   end
  20
  21   def test_successful_construction
  22     [:SIMPLEST_MANIFEST, :MULTIBLOCK_FILE_MANIFEST, :MULTILEVEL_MANIFEST].
  23         each do |manifest_name|
  24       manifest_text = SDKFixtures.const_get(manifest_name)
  25       coll = Arv::Collection.new(manifest_text)
  26       assert_equal(manifest_text, coll.manifest_text,
  27                    "did not get same manifest back out from #{manifest_name}")
  28     end
  29   end
  30
  31   def test_non_manifest_construction_error
  32     ["word", ". abc def", ". #{random_block} 0:", ". / !"].each do |m_text|
  33       assert_raises(ArgumentError,
  34                     "built collection from manifest #{m_text.inspect}") do
  35         Arv::Collection.new(m_text)
  36       end
  37     end
  38   end
  39
  40   def test_file_directory_conflict_construction_error
  41     assert_raises(ArgumentError) do
  42       Arv::Collection.new(NAME_CONFLICT_MANIFEST)
  43     end
  44   end
  45
  46   def test_no_implicit_normalization
  47     coll = Arv::Collection.new(NONNORMALIZED_MANIFEST)
  48     assert_equal(NONNORMALIZED_MANIFEST, coll.manifest_text)
  49   end
  50
  51   ### .normalize
  52
  53   def test_non_posix_path_handling
  54     m_text = "./.. #{random_block(9)} 0:5:. 5:4:..\n"
  55     coll = Arv::Collection.new(m_text.dup)
  56     coll.normalize
  57     assert_equal(m_text, coll.manifest_text)
  58   end
  59
  60   def test_escaping_through_normalization
  61     coll = Arv::Collection.new(MANY_ESCAPES_MANIFEST)
  62     coll.normalize
  63     # The result should simply duplicate the file spec.
  64     # The source file spec has an unescaped backslash in it.
  65     # It's OK for the Collection class to properly escape that.
  66     expect_text = MANY_ESCAPES_MANIFEST.sub(/ \d+:\d+:\S+/) do |file_spec|
  67       file_spec.gsub(/([^\\])(\\[^\\\d])/, '\1\\\\\2')
  68     end
  69     assert_equal(expect_text, coll.manifest_text)
  70   end
  71
  72   def test_concatenation_with_locator_overlap(over_index=0)
  73     blocks = random_blocks(4, 2)
  74     blocks_s = blocks.join(" ")
  75     coll = Arv::Collection.new(". %s 0:8:file\n. %s 0:4:file\n" %
  76                                [blocks_s, blocks[over_index, 2].join(" ")])
  77     coll.normalize
  78     assert_equal(". #{blocks_s} 0:8:file #{over_index * 2}:4:file\n",
  79                  coll.manifest_text)
  80   end
  81
  82   def test_concatenation_with_middle_locator_overlap
  83     test_concatenation_with_locator_overlap(1)
  84   end
  85
  86   def test_concatenation_with_end_locator_overlap
  87     test_concatenation_with_locator_overlap(2)
  88   end
  89
  90   def test_concatenation_with_partial_locator_overlap
  91     blocks = random_blocks(3, 3)
  92     coll = Arv::Collection
  93       .new(". %s 0:6:overlap\n. %s 0:6:overlap\n" %
  94            [blocks[0, 2].join(" "), blocks[1, 2].join(" ")])
  95     coll.normalize
  96     assert_equal(". #{blocks.join(' ')} 0:6:overlap 3:6:overlap\n",
  97                  coll.manifest_text)
  98   end
  99
 100   def test_normalize
 101     block = random_block
 102     coll = Arv::Collection.new(". #{block} 0:0:f2 0:0:f1\n")
 103     coll.normalize
 104     assert_equal(". #{block} 0:0:f1 0:0:f2\n", coll.manifest_text)
 105   end
 106
 107   def test_normalization_file_spans_two_whole_blocks(file_specs="0:10:f1",
 108                                                      num_blocks=2)
 109     blocks = random_blocks(num_blocks, 5)
 110     m_text = ". #{blocks.join(' ')} #{file_specs}\n"
 111     coll = Arv::Collection.new(m_text.dup)
 112     coll.normalize
 113     assert_equal(m_text, coll.manifest_text)
 114   end
 115
 116   def test_normalization_file_fits_beginning_block
 117     test_normalization_file_spans_two_whole_blocks("0:7:f1")
 118   end
 119
 120   def test_normalization_file_fits_end_block
 121     test_normalization_file_spans_two_whole_blocks("3:7:f1")
 122   end
 123
 124   def test_normalization_file_spans_middle
 125     test_normalization_file_spans_two_whole_blocks("3:5:f1")
 126   end
 127
 128   def test_normalization_file_spans_three_whole_blocks
 129     test_normalization_file_spans_two_whole_blocks("0:15:f1", 3)
 130   end
 131
 132   def test_normalization_file_skips_bytes
 133     test_normalization_file_spans_two_whole_blocks("0:3:f1 5:5:f1")
 134   end
 135
 136   def test_normalization_file_inserts_bytes
 137     test_normalization_file_spans_two_whole_blocks("0:3:f1 5:3:f1 3:2:f1")
 138   end
 139
 140   def test_normalization_file_duplicates_bytes
 141     test_normalization_file_spans_two_whole_blocks("2:3:f1 2:3:f1", 1)
 142   end
 143
 144   def test_normalization_dedups_locators
 145     blocks = random_blocks(2, 5)
 146     coll = Arv::Collection.new(". %s %s 1:8:f1 11:8:f1\n" %
 147                                [blocks.join(" "), blocks.reverse.join(" ")])
 148     coll.normalize
 149     assert_equal(". #{blocks.join(' ')} 1:8:f1 6:4:f1 0:4:f1\n",
 150                  coll.manifest_text)
 151   end
 152
 153   ### .cp_r
 154
 155   def test_simple_file_copy
 156     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 157     coll.cp_r("./simple.txt", "./new")
 158     assert_equal(SIMPLEST_MANIFEST.sub(" 0:9:", " 0:9:new 0:9:"),
 159                  coll.manifest_text)
 160   end
 161
 162   def test_copy_file_into_other_stream(target="./s1/f2", basename="f2")
 163     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 164     coll.cp_r("./f2", target)
 165     expected = "%s./s1 %s 0:5:f1 14:4:%s 5:4:f3\n" %
 166       [TWO_BY_TWO_MANIFEST_A.first,
 167        TWO_BY_TWO_BLOCKS.reverse.join(" "), basename]
 168     assert_equal(expected, coll.manifest_text)
 169   end
 170
 171   def test_implicit_copy_file_into_other_stream
 172     test_copy_file_into_other_stream("./s1")
 173   end
 174
 175   def test_copy_file_into_other_stream_with_new_name
 176     test_copy_file_into_other_stream("./s1/f2a", "f2a")
 177   end
 178
 179   def test_copy_file_over_in_other_stream(target="./s1/f1")
 180     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 181     coll.cp_r("./f1", target)
 182     expected = "%s./s1 %s 0:5:f1 14:4:f3\n" %
 183       [TWO_BY_TWO_MANIFEST_A.first, TWO_BY_TWO_BLOCKS.join(" ")]
 184     assert_equal(expected, coll.manifest_text)
 185   end
 186
 187   def test_implicit_copy_file_over_in_other_stream
 188     test_copy_file_over_in_other_stream("./s1")
 189   end
 190
 191   def test_simple_stream_copy
 192     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 193     coll.cp_r("./s1", "./sNew")
 194     new_line = TWO_BY_TWO_MANIFEST_A.last.sub("./s1 ", "./sNew ")
 195     assert_equal(TWO_BY_TWO_MANIFEST_S + new_line, coll.manifest_text)
 196   end
 197
 198   def test_copy_stream_into_other_stream(target="./dir2/subdir",
 199                                          basename="subdir")
 200     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 201     coll.cp_r("./dir1/subdir", target)
 202     new_line = MULTILEVEL_MANIFEST.lines[4].sub("./dir1/subdir ",
 203                                                 "./dir2/#{basename} ")
 204     assert_equal(MULTILEVEL_MANIFEST + new_line, coll.manifest_text)
 205   end
 206
 207   def test_implicit_copy_stream_into_other_stream
 208     test_copy_stream_into_other_stream("./dir2")
 209   end
 210
 211   def test_copy_stream_into_other_stream_with_new_name
 212     test_copy_stream_into_other_stream("./dir2/newsub", "newsub")
 213   end
 214
 215   def test_copy_stream_over_empty_stream
 216     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 217     (1..3).each do |file_num|
 218       coll.rm("./dir0/subdir/file#{file_num}")
 219     end
 220     coll.cp_r("./dir1/subdir", "./dir0")
 221     expected = MULTILEVEL_MANIFEST.lines
 222     expected[2] = expected[4].sub("./dir1/", "./dir0/")
 223     assert_equal(expected.join(""), coll.manifest_text)
 224   end
 225
 226   def test_copy_stream_over_file_raises_ENOTDIR
 227     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 228     assert_raises(Errno::ENOTDIR) do
 229       coll.cp_r("./s1", "./f2")
 230     end
 231   end
 232
 233   def test_copy_stream_over_nonempty_stream_merges_and_overwrites
 234     blocks = random_blocks(3, 9)
 235     manifest_a =
 236       ["./subdir #{blocks[0]} 0:1:s1 1:2:zero\n",
 237        "./zdir #{blocks[1]} 0:9:zfile\n",
 238        "./zdir/subdir #{blocks[2]} 0:1:s2 1:2:zero\n"]
 239     coll = Arv::Collection.new(manifest_a.join(""))
 240     coll.cp_r("./subdir", "./zdir")
 241     manifest_a[2] = "./zdir/subdir %s %s 0:1:s1 9:1:s2 1:2:zero\n" %
 242       [blocks[0], blocks[2]]
 243     assert_equal(manifest_a.join(""), coll.manifest_text)
 244   end
 245
 246   def test_copy_stream_into_substream(source="./dir1",
 247                                       target="./dir1/subdir/dir1")
 248     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 249     coll.cp_r(source, target)
 250     expected = MULTILEVEL_MANIFEST.lines.flat_map do |line|
 251       [line, line.gsub(/^#{Regexp.escape(source)}([\/ ])/, "#{target}\\1")].uniq
 252     end
 253     assert_equal(expected.sort.join(""), coll.manifest_text)
 254   end
 255
 256   def test_copy_root
 257     test_copy_stream_into_substream(".", "./root")
 258   end
 259
 260   def test_adding_to_root_after_copy
 261     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 262     coll.cp_r(".", "./root")
 263     src_coll = Arv::Collection.new(COLON_FILENAME_MANIFEST)
 264     coll.cp_r("./file:test.txt", ".", src_coll)
 265     got_lines = coll.manifest_text.lines
 266     assert_equal(2, got_lines.size)
 267     assert_match(/^\. \S{33,} \S{33,} 0:9:file:test\.txt 9:9:simple\.txt\n/,
 268                  got_lines.first)
 269     assert_equal(SIMPLEST_MANIFEST.sub(". ", "./root "), got_lines.last)
 270   end
 271
 272   def test_copy_chaining
 273     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 274     coll.cp_r("./simple.txt", "./a").cp_r("./a", "./b")
 275     assert_equal(SIMPLEST_MANIFEST.sub(" 0:9:", " 0:9:a 0:9:b 0:9:"),
 276                  coll.manifest_text)
 277   end
 278
 279   def prep_two_collections_for_copy(src_stream, dst_stream)
 280     blocks = random_blocks(2, 8)
 281     src_text = "#{src_stream} #{blocks.first} 0:8:f1\n"
 282     dst_text = "#{dst_stream} #{blocks.last} 0:8:f2\n"
 283     return [blocks, src_text, dst_text,
 284             Arv::Collection.new(src_text.dup),
 285             Arv::Collection.new(dst_text.dup)]
 286   end
 287
 288   def test_copy_file_from_other_collection(src_stream=".", dst_stream="./s1")
 289     blocks, src_text, dst_text, src_coll, dst_coll =
 290       prep_two_collections_for_copy(src_stream, dst_stream)
 291     dst_coll.cp_r("#{src_stream}/f1", dst_stream, src_coll)
 292     assert_equal("#{dst_stream} #{blocks.join(' ')} 0:8:f1 8:8:f2\n",
 293                  dst_coll.manifest_text)
 294     assert_equal(src_text, src_coll.manifest_text)
 295   end
 296
 297   def test_copy_file_from_other_collection_to_root
 298     test_copy_file_from_other_collection("./s1", ".")
 299   end
 300
 301   def test_copy_stream_from_other_collection
 302     blocks, src_text, dst_text, src_coll, dst_coll =
 303       prep_two_collections_for_copy("./s2", "./s1")
 304     dst_coll.cp_r("./s2", "./s1", src_coll)
 305     assert_equal(dst_text + src_text.sub("./s2 ", "./s1/s2 "),
 306                  dst_coll.manifest_text)
 307     assert_equal(src_text, src_coll.manifest_text)
 308   end
 309
 310   def test_copy_stream_from_other_collection_to_root
 311     blocks, src_text, dst_text, src_coll, dst_coll =
 312       prep_two_collections_for_copy("./s1", ".")
 313     dst_coll.cp_r("./s1", ".", src_coll)
 314     assert_equal(dst_text + src_text, dst_coll.manifest_text)
 315     assert_equal(src_text, src_coll.manifest_text)
 316   end
 317
 318   def test_copy_stream_contents
 319     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 320     coll.cp_r("./dir0/subdir/", "./dir1/subdir")
 321     expect_lines = MULTILEVEL_MANIFEST.lines
 322     expect_lines[4] = expect_lines[2].sub("./dir0/", "./dir1/")
 323     assert_equal(expect_lines.join(""), coll.manifest_text)
 324   end
 325
 326   def test_copy_stream_contents_into_root
 327     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 328     coll.cp_r("./s1/", ".")
 329     assert_equal(". %s 0:5:f1 14:4:f2 5:4:f3\n%s" %
 330                  [TWO_BY_TWO_BLOCKS.reverse.join(" "),
 331                   TWO_BY_TWO_MANIFEST_A.last],
 332                  coll.manifest_text)
 333   end
 334
 335   def test_copy_root_contents_into_stream
 336     # This is especially fun, because we're copying a parent into its child.
 337     # Make sure that happens depth-first.
 338     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 339     coll.cp_r("./", "./s1")
 340     assert_equal("%s./s1 %s 0:5:f1 5:4:f2 14:4:f3\n%s" %
 341                  [TWO_BY_TWO_MANIFEST_A.first, TWO_BY_TWO_BLOCKS.join(" "),
 342                   TWO_BY_TWO_MANIFEST_A.last.sub("./s1 ", "./s1/s1 ")],
 343                  coll.manifest_text)
 344   end
 345
 346   def test_copy_stream_contents_across_collections
 347     block = random_block(8)
 348     src_coll = Arv::Collection.new("./s1 #{block} 0:8:f1\n")
 349     dst_coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 350     dst_coll.cp_r("./s1/", "./s1", src_coll)
 351     assert_equal("%s./s1 %s %s 0:8:f1 13:4:f3\n" %
 352                  [TWO_BY_TWO_MANIFEST_A.first, block, TWO_BY_TWO_BLOCKS.last],
 353                  dst_coll.manifest_text)
 354   end
 355
 356   def test_copy_root_contents_across_collections
 357     block = random_block(8)
 358     src_coll = Arv::Collection.new(". #{block} 0:8:f1\n")
 359     dst_coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 360     dst_coll.cp_r("./", ".", src_coll)
 361     assert_equal(". %s %s 0:8:f1 13:4:f2\n%s" %
 362                  [block, TWO_BY_TWO_BLOCKS.first, TWO_BY_TWO_MANIFEST_A.last],
 363                  dst_coll.manifest_text)
 364   end
 365
 366   def test_copy_empty_source_path_raises_ArgumentError(src="", dst="./s1")
 367     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 368     assert_raises(ArgumentError) do
 369       coll.cp_r(src, dst)
 370     end
 371   end
 372
 373   def test_copy_empty_destination_path_raises_ArgumentError
 374     test_copy_empty_source_path_raises_ArgumentError(".", "")
 375   end
 376
 377   ### .exist?
 378
 379   def test_exist(test_method=:assert, path="f2")
 380     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 381     send(test_method, coll.exist?(path))
 382   end
 383
 384   def test_file_not_exist
 385     test_exist(:refute, "f3")
 386   end
 387
 388   def test_stream_exist
 389     test_exist(:assert, "s1")
 390   end
 391
 392   def test_file_inside_stream_exist
 393     test_exist(:assert, "s1/f1")
 394   end
 395
 396   def test_path_inside_stream_not_exist
 397     test_exist(:refute, "s1/nonexistent")
 398   end
 399
 400   def test_path_under_file_not_exist
 401     test_exist(:refute, "f2/nonexistent")
 402   end
 403
 404   def test_deep_substreams_not_exist
 405     test_exist(:refute, "a/b/c/d/e/f/g")
 406   end
 407
 408   ### .rename
 409
 410   def test_simple_file_rename
 411     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 412     coll.rename("./simple.txt", "./new")
 413     assert_equal(SIMPLEST_MANIFEST.sub(":simple.txt", ":new"),
 414                  coll.manifest_text)
 415   end
 416
 417   def test_rename_file_into_other_stream(target="./s1/f2", basename="f2")
 418     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 419     coll.rename("./f2", target)
 420     expected = ". %s 0:5:f1\n./s1 %s 0:5:f1 14:4:%s 5:4:f3\n" %
 421       [TWO_BY_TWO_BLOCKS.first,
 422        TWO_BY_TWO_BLOCKS.reverse.join(" "), basename]
 423     assert_equal(expected, coll.manifest_text)
 424   end
 425
 426   def test_implicit_rename_file_into_other_stream
 427     test_rename_file_into_other_stream("./s1")
 428   end
 429
 430   def test_rename_file_into_other_stream_with_new_name
 431     test_rename_file_into_other_stream("./s1/f2a", "f2a")
 432   end
 433
 434   def test_rename_file_over_in_other_stream(target="./s1/f1")
 435     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 436     coll.rename("./f1", target)
 437     expected = ". %s 5:4:f2\n./s1 %s 0:5:f1 14:4:f3\n" %
 438       [TWO_BY_TWO_BLOCKS.first, TWO_BY_TWO_BLOCKS.join(" ")]
 439     assert_equal(expected, coll.manifest_text)
 440   end
 441
 442   def test_implicit_rename_file_over_in_other_stream
 443     test_rename_file_over_in_other_stream("./s1")
 444   end
 445
 446   def test_simple_stream_rename
 447     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 448     coll.rename("./s1", "./newS")
 449     assert_equal(TWO_BY_TWO_MANIFEST_S.sub("\n./s1 ", "\n./newS "),
 450                  coll.manifest_text)
 451   end
 452
 453   def test_rename_stream_into_other_stream(target="./dir2/subdir",
 454                                            basename="subdir")
 455     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 456     coll.rename("./dir1/subdir", target)
 457     expected = MULTILEVEL_MANIFEST.lines
 458     replaced_line = expected.delete_at(4)
 459     expected << replaced_line.sub("./dir1/subdir ", "./dir2/#{basename} ")
 460     assert_equal(expected.join(""), coll.manifest_text)
 461   end
 462
 463   def test_implicit_rename_stream_into_other_stream
 464     test_rename_stream_into_other_stream("./dir2")
 465   end
 466
 467   def test_rename_stream_into_other_stream_with_new_name
 468     test_rename_stream_into_other_stream("./dir2/newsub", "newsub")
 469   end
 470
 471   def test_rename_stream_over_empty_stream
 472     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 473     (1..3).each do |file_num|
 474       coll.rm("./dir0/subdir/file#{file_num}")
 475     end
 476     coll.rename("./dir1/subdir", "./dir0")
 477     expected = MULTILEVEL_MANIFEST.lines
 478     expected[2] = expected.delete_at(4).sub("./dir1/", "./dir0/")
 479     assert_equal(expected.sort.join(""), coll.manifest_text)
 480   end
 481
 482   def test_rename_stream_over_file_raises_ENOTDIR
 483     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 484     assert_raises(Errno::ENOTDIR) do
 485       coll.rename("./s1", "./f2")
 486     end
 487   end
 488
 489   def test_rename_stream_over_nonempty_stream_raises_ENOTEMPTY
 490     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 491     assert_raises(Errno::ENOTEMPTY) do
 492       coll.rename("./dir1/subdir", "./dir0")
 493     end
 494   end
 495
 496   def test_rename_stream_into_substream(source="./dir1",
 497                                         target="./dir1/subdir/dir1")
 498     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 499     coll.rename(source, target)
 500     assert_equal(MULTILEVEL_MANIFEST.gsub(/^#{Regexp.escape(source)}([\/ ])/m,
 501                                           "#{target}\\1"),
 502                  coll.manifest_text)
 503   end
 504
 505   def test_rename_root
 506     test_rename_stream_into_substream(".", "./root")
 507   end
 508
 509   def test_adding_to_root_after_rename
 510     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 511     coll.rename(".", "./root")
 512     src_coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 513     coll.cp_r("./simple.txt", ".", src_coll)
 514     assert_equal(SIMPLEST_MANIFEST + SIMPLEST_MANIFEST.sub(". ", "./root "),
 515                  coll.manifest_text)
 516   end
 517
 518   def test_rename_chaining
 519     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 520     coll.rename("./simple.txt", "./x").rename("./x", "./simple.txt")
 521     assert_equal(SIMPLEST_MANIFEST, coll.manifest_text)
 522   end
 523
 524   ### .rm
 525
 526   def test_simple_remove
 527     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S.dup)
 528     coll.rm("./f2")
 529     assert_equal(TWO_BY_TWO_MANIFEST_S.sub(" 5:4:f2", ""), coll.manifest_text)
 530   end
 531
 532   def empty_stream_and_assert(expect_index=0)
 533     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 534     yield coll
 535     assert_equal(TWO_BY_TWO_MANIFEST_A[expect_index], coll.manifest_text)
 536   end
 537
 538   def test_remove_all_files_in_substream
 539     empty_stream_and_assert do |coll|
 540       coll.rm("./s1/f1")
 541       coll.rm("./s1/f3")
 542     end
 543   end
 544
 545   def test_remove_all_files_in_root_stream
 546     empty_stream_and_assert(1) do |coll|
 547       coll.rm("./f1")
 548       coll.rm("./f2")
 549     end
 550   end
 551
 552   def test_chaining_removes
 553     empty_stream_and_assert do |coll|
 554       coll.rm("./s1/f1").rm("./s1/f3")
 555     end
 556   end
 557
 558   def test_remove_last_file
 559     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 560     coll.rm("./simple.txt")
 561     assert_equal("", coll.manifest_text)
 562   end
 563
 564   def test_remove_nonexistent_file_raises_ENOENT(path="./NoSuchFile",
 565                                                  method=:rm)
 566     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 567     assert_raises(Errno::ENOENT) do
 568       coll.send(method, path)
 569     end
 570   end
 571
 572   def test_remove_from_nonexistent_stream_raises_ENOENT
 573     test_remove_nonexistent_file_raises_ENOENT("./NoSuchStream/simple.txt")
 574   end
 575
 576   def test_remove_stream_raises_EISDIR(path="./s1")
 577     coll = Arv::Collection.new(TWO_BY_TWO_MANIFEST_S)
 578     assert_raises(Errno::EISDIR) do
 579       coll.rm(path)
 580     end
 581   end
 582
 583   def test_remove_root_raises_EISDIR
 584     test_remove_stream_raises_EISDIR(".")
 585   end
 586
 587   def test_remove_empty_string_raises_ArgumentError
 588     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 589     assert_raises(ArgumentError) do
 590       coll.rm("")
 591     end
 592   end
 593
 594   ### rm_r
 595
 596   def test_recursive_remove
 597     empty_stream_and_assert do |coll|
 598       coll.rm_r("./s1")
 599     end
 600   end
 601
 602   def test_recursive_remove_on_files
 603     empty_stream_and_assert do |coll|
 604       coll.rm_r("./s1/f1")
 605       coll.rm_r("./s1/f3")
 606     end
 607   end
 608
 609   def test_recursive_remove_root
 610     coll = Arv::Collection.new(MULTILEVEL_MANIFEST)
 611     coll.rm_r(".")
 612     assert_equal("", coll.manifest_text)
 613   end
 614
 615   def test_rm_r_nonexistent_file_raises_ENOENT(path="./NoSuchFile")
 616     test_remove_nonexistent_file_raises_ENOENT("./NoSuchFile", :rm_r)
 617   end
 618
 619   def test_rm_r_from_nonexistent_stream_raises_ENOENT
 620     test_remove_nonexistent_file_raises_ENOENT("./NoSuchStream/file", :rm_r)
 621   end
 622
 623   def test_rm_r_empty_string_raises_ArgumentError
 624     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 625     assert_raises(ArgumentError) do
 626       coll.rm_r("")
 627     end
 628   end
 629
 630   ### .modified?
 631
 632   def test_new_collection_unmodified(*args)
 633     coll = Arv::Collection.new(*args)
 634     yield coll if block_given?
 635     refute(coll.modified?)
 636   end
 637
 638   def test_collection_unmodified_after_instantiation
 639     test_new_collection_unmodified(SIMPLEST_MANIFEST)
 640   end
 641
 642   def test_collection_unmodified_after_mark
 643     test_new_collection_unmodified(SIMPLEST_MANIFEST) do |coll|
 644       coll.cp_r("./simple.txt", "./copy")
 645       coll.unmodified
 646     end
 647   end
 648
 649   def check_collection_modified
 650     coll = Arv::Collection.new(SIMPLEST_MANIFEST)
 651     yield coll
 652     assert(coll.modified?)
 653   end
 654
 655   def test_collection_modified_after_copy
 656     check_collection_modified do |coll|
 657       coll.cp_r("./simple.txt", "./copy")
 658     end
 659   end
 660
 661   def test_collection_modified_after_remove
 662     check_collection_modified do |coll|
 663       coll.rm("./simple.txt")
 664     end
 665   end
 666
 667   def test_collection_modified_after_rename
 668     check_collection_modified do |coll|
 669       coll.rename("./simple.txt", "./newname")
 670     end
 671   end
 672 end