X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/5b5be8dfac71c7db9d5a966485fa04f24fd20957..10dc1ca759592b7281265ac1378bda126c979208:/services/api/test/unit/container_request_test.rb diff --git a/services/api/test/unit/container_request_test.rb b/services/api/test/unit/container_request_test.rb index 70ad11e0f4..81b49ff4fc 100644 --- a/services/api/test/unit/container_request_test.rb +++ b/services/api/test/unit/container_request_test.rb @@ -69,7 +69,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr.container_image = "img3" cr.cwd = "/tmp3" cr.environment = {"BUP" => "BOP"} - cr.mounts = {"BAR" => "BAZ"} + cr.mounts = {"BAR" => {"kind" => "BAZ"}} cr.output_path = "/tmp4" cr.priority = 2 cr.runtime_constraints = {"vcpus" => 4} @@ -81,29 +81,33 @@ class ContainerRequestTest < ActiveSupport::TestCase end [ - {"vcpus" => 1}, - {"vcpus" => 1, "ram" => nil}, - {"vcpus" => 0, "ram" => 123}, - {"vcpus" => "1", "ram" => "123"} - ].each do |invalid_constraints| - test "Create with #{invalid_constraints}" do + {"runtime_constraints" => {"vcpus" => 1}}, + {"runtime_constraints" => {"vcpus" => 1, "ram" => nil}}, + {"runtime_constraints" => {"vcpus" => 0, "ram" => 123}}, + {"runtime_constraints" => {"vcpus" => "1", "ram" => "123"}}, + {"mounts" => {"FOO" => "BAR"}}, + {"mounts" => {"FOO" => {}}}, + {"mounts" => {"FOO" => {"kind" => "tmp", "capacity" => 42.222}}}, + {"command" => ["echo", 55]}, + {"environment" => {"FOO" => 55}} + ].each do |value| + test "Create with invalid #{value}" do set_user_from_auth :active assert_raises(ActiveRecord::RecordInvalid) do - cr = create_minimal_req!(state: "Committed", - priority: 1, - runtime_constraints: invalid_constraints) + cr = create_minimal_req!({state: "Committed", + priority: 1}.merge(value)) cr.save! end end - test "Update with #{invalid_constraints}" do + test "Update with invalid #{value}" do set_user_from_auth :active cr = create_minimal_req!(state: "Uncommitted", priority: 1) cr.save! assert_raises(ActiveRecord::RecordInvalid) do cr = ContainerRequest.find_by_uuid cr.uuid - cr.update_attributes!(state: "Committed", - runtime_constraints: invalid_constraints) + cr.update_attributes!({state: "Committed", + priority: 1}.merge(value)) end end end @@ -200,6 +204,7 @@ class ContainerRequestTest < ActiveSupport::TestCase test "Request is finalized when its container is cancelled" do set_user_from_auth :active cr = create_minimal_req!(priority: 1, state: "Committed", container_count_max: 1) + assert_equal users(:active).uuid, cr.modified_by_user_uuid act_as_system_user do Container.find_by_uuid(cr.container_uuid). @@ -208,6 +213,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr.reload assert_equal "Final", cr.state + assert_equal users(:active).uuid, cr.modified_by_user_uuid end test "Request is finalized when its container is completed" do @@ -216,6 +222,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr = create_minimal_req!(owner_uuid: project.uuid, priority: 1, state: "Committed") + assert_equal users(:active).uuid, cr.modified_by_user_uuid c = act_as_system_user do c = Container.find_by_uuid(cr.container_uuid) @@ -237,6 +244,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr.reload assert_equal "Final", cr.state + assert_equal users(:active).uuid, cr.modified_by_user_uuid ['output', 'log'].each do |out_type| pdh = Container.find_by_uuid(cr.container_uuid).send(out_type) assert_equal(1, Collection.where(portable_data_hash: pdh, @@ -257,10 +265,13 @@ class ContainerRequestTest < ActiveSupport::TestCase c = Container.find_by_uuid cr.container_uuid assert_operator 0, :<, c.priority + lock_and_run(c) - cr2 = create_minimal_req! - cr2.update_attributes!(priority: 10, state: "Committed", requesting_container_uuid: c.uuid, command: ["echo", "foo2"], container_count_max: 1) - cr2.reload + cr2 = with_container_auth(c) do + create_minimal_req!(priority: 10, state: "Committed", container_count_max: 1, command: ["echo", "foo2"]) + end + assert_not_nil cr2.requesting_container_uuid + assert_equal users(:active).uuid, cr2.modified_by_user_uuid c2 = Container.find_by_uuid cr2.container_uuid assert_operator 0, :<, c2.priority @@ -275,6 +286,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr2.reload assert_equal 0, cr2.priority + assert_equal users(:active).uuid, cr2.modified_by_user_uuid c2.reload assert_equal 0, c2.priority @@ -367,7 +379,7 @@ class ContainerRequestTest < ActiveSupport::TestCase end [ - ['running_container_auth', 'zzzzz-dz642-runningcontainr', 1], + ['running_container_auth', 'zzzzz-dz642-runningcontainr', 501], ['active_no_prefs', nil, 0], ].each do |token, expected, expected_priority| test "create as #{token} and expect requesting_container_uuid to be #{expected}" do @@ -607,7 +619,7 @@ class ContainerRequestTest < ActiveSupport::TestCase test "requesting_container_uuid at create is not allowed" do set_user_from_auth :active - assert_raises(ActiveRecord::RecordNotSaved) do + assert_raises(ActiveRecord::RecordInvalid) do create_minimal_req!(state: "Uncommitted", priority: 1, requesting_container_uuid: 'youcantdothat') end end @@ -749,12 +761,109 @@ class ContainerRequestTest < ActiveSupport::TestCase assert_equal ContainerRequest::Final, cr3.state end + [ + [false, ActiveRecord::RecordInvalid], + [true, nil], + ].each do |preemptible_conf, expected| + test "having Rails.configuration.preemptible_instances=#{preemptible_conf}, create preemptible container request and verify #{expected}" do + sp = {"preemptible" => true} + common_attrs = {cwd: "test", + priority: 1, + command: ["echo", "hello"], + output_path: "test", + scheduling_parameters: sp, + mounts: {"test" => {"kind" => "json"}}} + Rails.configuration.preemptible_instances = preemptible_conf + set_user_from_auth :active + + cr = create_minimal_req!(common_attrs) + cr.state = ContainerRequest::Committed + + if !expected.nil? + assert_raises(expected) do + cr.save! + end + else + cr.save! + assert_equal sp, cr.scheduling_parameters + end + end + end + + [ + 'zzzzz-dz642-runningcontainr', + nil, + ].each do |requesting_c| + test "having preemptible instances active on the API server, a committed #{requesting_c.nil? ? 'non-':''}child CR should not ask for preemptible instance if parameter already set to false" do + common_attrs = {cwd: "test", + priority: 1, + command: ["echo", "hello"], + output_path: "test", + scheduling_parameters: {"preemptible" => false}, + mounts: {"test" => {"kind" => "json"}}} + + Rails.configuration.preemptible_instances = true + set_user_from_auth :active + + if requesting_c + cr = with_container_auth(Container.find_by_uuid requesting_c) do + create_minimal_req!(common_attrs) + end + assert_not_nil cr.requesting_container_uuid + else + cr = create_minimal_req!(common_attrs) + end + + cr.state = ContainerRequest::Committed + cr.save! + + assert_equal false, cr.scheduling_parameters['preemptible'] + end + end + + [ + [true, 'zzzzz-dz642-runningcontainr', true], + [true, nil, nil], + [false, 'zzzzz-dz642-runningcontainr', nil], + [false, nil, nil], + ].each do |preemptible_conf, requesting_c, schedule_preemptible| + test "having Rails.configuration.preemptible_instances=#{preemptible_conf}, #{requesting_c.nil? ? 'non-':''}child CR should #{schedule_preemptible ? '':'not'} ask for preemptible instance by default" do + common_attrs = {cwd: "test", + priority: 1, + command: ["echo", "hello"], + output_path: "test", + mounts: {"test" => {"kind" => "json"}}} + + Rails.configuration.preemptible_instances = preemptible_conf + set_user_from_auth :active + + if requesting_c + cr = with_container_auth(Container.find_by_uuid requesting_c) do + create_minimal_req!(common_attrs) + end + assert_not_nil cr.requesting_container_uuid + else + cr = create_minimal_req!(common_attrs) + end + + cr.state = ContainerRequest::Committed + cr.save! + + assert_equal schedule_preemptible, cr.scheduling_parameters['preemptible'] + end + end + [ [{"partitions" => ["fastcpu","vfastcpu", 100]}, ContainerRequest::Committed, ActiveRecord::RecordInvalid], [{"partitions" => ["fastcpu","vfastcpu", 100]}, ContainerRequest::Uncommitted], [{"partitions" => "fastcpu"}, ContainerRequest::Committed, ActiveRecord::RecordInvalid], [{"partitions" => "fastcpu"}, ContainerRequest::Uncommitted], [{"partitions" => ["fastcpu","vfastcpu"]}, ContainerRequest::Committed], + [{"max_run_time" => "one day"}, ContainerRequest::Committed, ActiveRecord::RecordInvalid], + [{"max_run_time" => "one day"}, ContainerRequest::Uncommitted], + [{"max_run_time" => -1}, ContainerRequest::Committed, ActiveRecord::RecordInvalid], + [{"max_run_time" => -1}, ContainerRequest::Uncommitted], + [{"max_run_time" => 86400}, ContainerRequest::Committed], ].each do |sp, state, expected| test "create container request with scheduling_parameters #{sp} in state #{state} and verify #{expected}" do common_attrs = {cwd: "test", @@ -781,6 +890,26 @@ class ContainerRequestTest < ActiveSupport::TestCase end end + test "Having preemptible_instances=true create a committed child container request and verify the scheduling parameter of its container" do + common_attrs = {cwd: "test", + priority: 1, + command: ["echo", "hello"], + output_path: "test", + state: ContainerRequest::Committed, + mounts: {"test" => {"kind" => "json"}}} + set_user_from_auth :active + Rails.configuration.preemptible_instances = true + + cr = with_container_auth(Container.find_by_uuid 'zzzzz-dz642-runningcontainr') do + create_minimal_req!(common_attrs) + end + assert_equal 'zzzzz-dz642-runningcontainr', cr.requesting_container_uuid + assert_equal true, cr.scheduling_parameters["preemptible"] + + c = Container.find_by_uuid(cr.container_uuid) + assert_equal true, c.scheduling_parameters["preemptible"] + end + [['Committed', true, {name: "foobar", priority: 123}], ['Committed', false, {container_count: 2}], ['Committed', false, {container_count: 0}],