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