services/api/test/unit/container_request_test.rb

   1 require 'test_helper'
   2
   3 class ContainerRequestTest < ActiveSupport::TestCase
   4   def create_minimal_req! attrs={}
   5     defaults = {
   6       command: ["echo", "foo"],
   7       container_image: links(:docker_image_collection_tag).name,
   8       cwd: "/tmp",
   9       environment: {},
  10       mounts: {"/out" => {"kind" => "tmp", "capacity" => 1000000}},
  11       output_path: "/out",
  12       runtime_constraints: {"vcpus" => 1, "ram" => 2},
  13       name: "foo",
  14       description: "bar",
  15     }
  16     cr = ContainerRequest.create!(defaults.merge(attrs))
  17     cr.reload
  18     return cr
  19   end
  20
  21   def check_bogus_states cr
  22     [nil, "Flubber"].each do |state|
  23       assert_raises(ActiveRecord::RecordInvalid) do
  24         cr.state = state
  25         cr.save!
  26       end
  27       cr.reload
  28     end
  29   end
  30
  31   test "Container request create" do
  32     set_user_from_auth :active
  33     cr = create_minimal_req!
  34
  35     assert_nil cr.container_uuid
  36     assert_nil cr.priority
  37
  38     check_bogus_states cr
  39
  40     # Ensure we can modify all attributes
  41     cr.command = ["echo", "foo3"]
  42     cr.container_image = "img3"
  43     cr.cwd = "/tmp3"
  44     cr.environment = {"BUP" => "BOP"}
  45     cr.mounts = {"BAR" => "BAZ"}
  46     cr.output_path = "/tmp4"
  47     cr.priority = 2
  48     cr.runtime_constraints = {"vcpus" => 4}
  49     cr.name = "foo3"
  50     cr.description = "bar3"
  51     cr.save!
  52
  53     assert_nil cr.container_uuid
  54   end
  55
  56   test "Container request constraints must include valid vcpus and ram fields when committed" do
  57     set_user_from_auth :active
  58     # Validations on creation
  59     [{"vcpus" => 1},
  60      {"vcpus" => 1, "ram" => nil},
  61      {"vcpus" => 0, "ram" => 123}].each do |invalid_constraint|
  62       assert_raises(ActiveRecord::RecordInvalid) do
  63         cr = create_minimal_req!(state: "Committed", priority: 1,
  64                                  runtime_constraints: invalid_constraint)
  65         cr.save!
  66       end
  67     end
  68     cr = create_minimal_req!(state: "Committed", priority: 1)
  69     cr.save!
  70     # Validations on update
  71     cr = create_minimal_req!(state: "Uncommitted", priority: 1)
  72     cr.save!
  73
  74     [{"vcpus" => 1},
  75      {"vcpus" => 1, "ram" => nil},
  76      {"vcpus" => 0, "ram" => 123}].each do |invalid_constraint|
  77       cr = ContainerRequest.find_by_uuid cr.uuid
  78       assert_raises(ActiveRecord::RecordInvalid) do
  79         cr.update_attributes!(state: "Committed",
  80                               runtime_constraints: invalid_constraint)
  81         cr.save!
  82       end
  83     end
  84     cr = ContainerRequest.find_by_uuid cr.uuid
  85     cr.update_attributes!(state: "Committed",
  86                           runtime_constraints: {"vcpus" => 1, "ram" => 23})
  87     cr.save!
  88   end
  89
  90   test "Container request priority must be non-nil" do
  91     set_user_from_auth :active
  92     cr = create_minimal_req!(priority: nil)
  93     cr.state = "Committed"
  94     assert_raises(ActiveRecord::RecordInvalid) do
  95       cr.save!
  96     end
  97   end
  98
  99   test "Container request commit" do
 100     set_user_from_auth :active
 101     cr = create_minimal_req!(runtime_constraints: {"vcpus" => 2, "ram" => 30})
 102
 103     assert_nil cr.container_uuid
 104
 105     cr.reload
 106     cr.state = "Committed"
 107     cr.priority = 1
 108     cr.save!
 109
 110     cr.reload
 111
 112     assert_not_nil cr.container_uuid
 113     c = Container.find_by_uuid cr.container_uuid
 114     assert_not_nil c
 115     assert_equal ["echo", "foo"], c.command
 116     assert_equal collections(:docker_image).portable_data_hash, c.container_image
 117     assert_equal "/tmp", c.cwd
 118     assert_equal({}, c.environment)
 119     assert_equal({"/out" => {"kind"=>"tmp", "capacity"=>1000000}}, c.mounts)
 120     assert_equal "/out", c.output_path
 121     assert_equal({"vcpus" => 2, "ram" => 30}, c.runtime_constraints)
 122     assert_equal 1, c.priority
 123
 124     assert_raises(ActiveRecord::RecordInvalid) do
 125       cr.priority = nil
 126       cr.save!
 127     end
 128
 129     cr.priority = 0
 130     cr.save!
 131
 132     cr.reload
 133     c.reload
 134     assert_equal 0, cr.priority
 135     assert_equal 0, c.priority
 136   end
 137
 138
 139   test "Container request max priority" do
 140     set_user_from_auth :active
 141     cr = create_minimal_req!(priority: 5, state: "Committed")
 142
 143     c = Container.find_by_uuid cr.container_uuid
 144     assert_equal 5, c.priority
 145
 146     cr2 = create_minimal_req!
 147     cr2.priority = 10
 148     cr2.state = "Committed"
 149     cr2.container_uuid = cr.container_uuid
 150     act_as_system_user do
 151       cr2.save!
 152     end
 153
 154     # cr and cr2 have priority 5 and 10, and are being satisfied by
 155     # the same container c, so c's priority should be
 156     # max(priority)=10.
 157     c.reload
 158     assert_equal 10, c.priority
 159
 160     cr2.update_attributes!(priority: 0)
 161
 162     c.reload
 163     assert_equal 5, c.priority
 164
 165     cr.update_attributes!(priority: 0)
 166
 167     c.reload
 168     assert_equal 0, c.priority
 169   end
 170
 171
 172   test "Independent container requests" do
 173     set_user_from_auth :active
 174     cr1 = create_minimal_req!(command: ["foo", "1"], priority: 5, state: "Committed")
 175     cr2 = create_minimal_req!(command: ["foo", "2"], priority: 10, state: "Committed")
 176
 177     c1 = Container.find_by_uuid cr1.container_uuid
 178     assert_equal 5, c1.priority
 179
 180     c2 = Container.find_by_uuid cr2.container_uuid
 181     assert_equal 10, c2.priority
 182
 183     cr1.update_attributes!(priority: 0)
 184
 185     c1.reload
 186     assert_equal 0, c1.priority
 187
 188     c2.reload
 189     assert_equal 10, c2.priority
 190   end
 191
 192   test "Request is finalized when its container is cancelled" do
 193     set_user_from_auth :active
 194     cr = create_minimal_req!(priority: 1, state: "Committed")
 195
 196     act_as_system_user do
 197       Container.find_by_uuid(cr.container_uuid).
 198         update_attributes!(state: Container::Cancelled)
 199     end
 200
 201     cr.reload
 202     assert_equal "Final", cr.state
 203   end
 204
 205   test "Request is finalized when its container is completed" do
 206     set_user_from_auth :active
 207     cr = create_minimal_req!(priority: 1, state: "Committed")
 208
 209     c = act_as_system_user do
 210       c = Container.find_by_uuid(cr.container_uuid)
 211       c.update_attributes!(state: Container::Locked)
 212       c.update_attributes!(state: Container::Running)
 213       c
 214     end
 215
 216     cr.reload
 217     assert_equal "Committed", cr.state
 218
 219     act_as_system_user do
 220       c.update_attributes!(state: Container::Complete)
 221     end
 222
 223     cr.reload
 224     assert_equal "Final", cr.state
 225   end
 226
 227   test "Container makes container request, then is cancelled" do
 228     set_user_from_auth :active
 229     cr = create_minimal_req!(priority: 5, state: "Committed")
 230
 231     c = Container.find_by_uuid cr.container_uuid
 232     assert_equal 5, c.priority
 233
 234     cr2 = create_minimal_req!(priority: 10, state: "Committed", requesting_container_uuid: c.uuid)
 235
 236     c2 = Container.find_by_uuid cr2.container_uuid
 237     assert_equal 10, c2.priority
 238
 239     act_as_system_user do
 240       c.state = "Cancelled"
 241       c.save!
 242     end
 243
 244     cr.reload
 245     assert_equal "Final", cr.state
 246
 247     cr2.reload
 248     assert_equal 0, cr2.priority
 249
 250     c2.reload
 251     assert_equal 0, c2.priority
 252   end
 253
 254   [
 255     ['active', 'zzzzz-dz642-runningcontainr'],
 256     ['active_no_prefs', nil],
 257   ].each do |token, expected|
 258     test "create as #{token} and expect requesting_container_uuid to be #{expected}" do
 259       set_user_from_auth token
 260       cr = ContainerRequest.create(container_image: "img", output_path: "/tmp", command: ["echo", "foo"])
 261       assert_not_nil cr.uuid, 'uuid should be set for newly created container_request'
 262       assert_equal expected, cr.requesting_container_uuid
 263     end
 264   end
 265
 266   [[{"vcpus" => [2, nil]},
 267     lambda { |resolved| resolved["vcpus"] == 2 }],
 268    [{"vcpus" => [3, 7]},
 269     lambda { |resolved| resolved["vcpus"] == 3 }],
 270    [{"vcpus" => 4},
 271     lambda { |resolved| resolved["vcpus"] == 4 }],
 272    [{"ram" => [1000000000, 2000000000]},
 273     lambda { |resolved| resolved["ram"] == 1000000000 }],
 274    [{"ram" => [1234234234]},
 275     lambda { |resolved| resolved["ram"] == 1234234234 }],
 276   ].each do |rc, okfunc|
 277     test "resolve runtime constraint range #{rc} to values" do
 278       cr = ContainerRequest.new(runtime_constraints: rc)
 279       resolved = cr.send :runtime_constraints_for_container
 280       assert(okfunc.call(resolved),
 281              "container runtime_constraints was #{resolved.inspect}")
 282     end
 283   end
 284
 285   [[{"/out" => {
 286         "kind" => "collection",
 287         "uuid" => "zzzzz-4zz18-znfnqtbbv4spc3w",
 288         "path" => "/foo"}},
 289     lambda do |resolved|
 290       resolved["/out"] == {
 291         "portable_data_hash" => "1f4b0bc7583c2a7f9102c395f4ffc5e3+45",
 292         "kind" => "collection",
 293         "path" => "/foo",
 294       }
 295     end],
 296    [{"/out" => {
 297         "kind" => "collection",
 298         "uuid" => "zzzzz-4zz18-znfnqtbbv4spc3w",
 299         "portable_data_hash" => "1f4b0bc7583c2a7f9102c395f4ffc5e3+45",
 300         "path" => "/foo"}},
 301     lambda do |resolved|
 302       resolved["/out"] == {
 303         "portable_data_hash" => "1f4b0bc7583c2a7f9102c395f4ffc5e3+45",
 304         "kind" => "collection",
 305         "path" => "/foo",
 306       }
 307     end],
 308   ].each do |mounts, okfunc|
 309     test "resolve mounts #{mounts.inspect} to values" do
 310       set_user_from_auth :active
 311       cr = ContainerRequest.new(mounts: mounts)
 312       resolved = cr.send :mounts_for_container
 313       assert(okfunc.call(resolved),
 314              "mounts_for_container returned #{resolved.inspect}")
 315     end
 316   end
 317
 318   test 'mount unreadable collection' do
 319     set_user_from_auth :spectator
 320     m = {
 321       "/foo" => {
 322         "kind" => "collection",
 323         "uuid" => "zzzzz-4zz18-znfnqtbbv4spc3w",
 324         "path" => "/foo",
 325       },
 326     }
 327     cr = ContainerRequest.new(mounts: m)
 328     assert_raises(ActiveRecord::RecordNotFound) do
 329       cr.send :mounts_for_container
 330     end
 331   end
 332
 333   test 'mount collection with mismatched UUID and PDH' do
 334     set_user_from_auth :active
 335     m = {
 336       "/foo" => {
 337         "kind" => "collection",
 338         "uuid" => "zzzzz-4zz18-znfnqtbbv4spc3w",
 339         "portable_data_hash" => "fa7aeb5140e2848d39b416daeef4ffc5+45",
 340         "path" => "/foo",
 341       },
 342     }
 343     cr = ContainerRequest.new(mounts: m)
 344     assert_raises(ArgumentError) do
 345       cr.send :mounts_for_container
 346     end
 347   end
 348
 349   ['arvados/apitestfixture:latest',
 350    'arvados/apitestfixture',
 351    'd8309758b8fe2c81034ffc8a10c36460b77db7bc5e7b448c4e5b684f9d95a678',
 352   ].each do |tag|
 353     test "container_image_for_container(#{tag.inspect})" do
 354       set_user_from_auth :active
 355       cr = ContainerRequest.new(container_image: tag)
 356       resolved = cr.send :container_image_for_container
 357       assert_equal resolved, collections(:docker_image).portable_data_hash
 358     end
 359   end
 360
 361   test "container_image_for_container(pdh)" do
 362     set_user_from_auth :active
 363     pdh = collections(:docker_image).portable_data_hash
 364     cr = ContainerRequest.new(container_image: pdh)
 365     resolved = cr.send :container_image_for_container
 366     assert_equal resolved, pdh
 367   end
 368
 369   ['acbd18db4cc2f85cedef654fccc4a4d8+3',
 370    'ENOEXIST',
 371    'arvados/apitestfixture:ENOEXIST',
 372   ].each do |img|
 373     test "container_image_for_container(#{img.inspect}) => 404" do
 374       set_user_from_auth :active
 375       cr = ContainerRequest.new(container_image: img)
 376       assert_raises(ActiveRecord::RecordNotFound) do
 377         cr.send :container_image_for_container
 378       end
 379     end
 380   end
 381 end