X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/7b9112dbc270ea338fee756f583bb76870f2e391..55727c5da7f9c5a549e42750d9966b53a486ca68:/services/api/test/unit/job_test.rb diff --git a/services/api/test/unit/job_test.rb b/services/api/test/unit/job_test.rb index 65ca9357dc..761953e8eb 100644 --- a/services/api/test/unit/job_test.rb +++ b/services/api/test/unit/job_test.rb @@ -15,7 +15,7 @@ class JobTest < ActiveSupport::TestCase { script: "hash", script_version: "master", - repository: "foo", + repository: "active/foo", }.merge(merge_me) end @@ -78,6 +78,36 @@ class JobTest < ActiveSupport::TestCase assert(job.invalid?, "Job with bad Docker tag valid") end + [ + false, + true + ].each do |use_config| + test "Job with no Docker image uses default docker image when configuration is set #{use_config}" do + default_docker_image = collections(:docker_image)[:portable_data_hash] + Rails.configuration.default_docker_image_for_jobs = default_docker_image if use_config + + job = Job.new job_attrs + assert job.valid?, job.errors.full_messages.to_s + + if use_config + refute_nil job.docker_image_locator + assert_equal default_docker_image, job.docker_image_locator + else + assert_nil job.docker_image_locator + end + end + end + + test "create a job with a disambiguated script_version branch name" do + job = Job. + new(script: "testscript", + script_version: "heads/7387838c69a21827834586cc42b467ff6c63293b", + repository: "active/shabranchnames", + script_parameters: {}) + assert(job.save) + assert_equal("abec49829bf1758413509b7ffcab32a771b71e81", job.script_version) + end + test "locate a Docker image with a partial hash" do image_hash = links(:docker_image_collection_hash).name[0..24] job = Job.new job_attrs(runtime_constraints: @@ -155,7 +185,7 @@ class JobTest < ActiveSupport::TestCase # Ensure valid_attrs doesn't produce errors -- otherwise we will # not know whether errors reported below are actually caused by # invalid_attrs. - dummy = Job.create! job_attrs + Job.create! job_attrs job = Job.create job_attrs(invalid_attrs) assert_raises(ActiveRecord::RecordInvalid, ArgumentError, @@ -189,12 +219,11 @@ class JobTest < ActiveSupport::TestCase ].each do |parameters| test "verify job status #{parameters}" do job = Job.create! job_attrs - assert job.valid?, job.errors.full_messages.to_s assert_equal 'Queued', job.state, "job.state" parameters.each do |parameter| expectations = parameter[2] - if parameter[1] == 'use_current_user_uuid' + if 'use_current_user_uuid' == parameter[1] parameter[1] = Thread.current[:user].uuid end @@ -278,25 +307,43 @@ class JobTest < ActiveSupport::TestCase assert_equal "Failed", job.state end + test "admin user can cancel a running job despite lock" do + set_user_from_auth :active_trustedclient + job = Job.create! job_attrs + job.lock current_user.uuid + assert_equal Job::Running, job.state + + set_user_from_auth :spectator + assert_raises do + job.update_attributes!(state: Job::Cancelled) + end + + set_user_from_auth :admin + job.reload + assert_equal Job::Running, job.state + job.update_attributes!(state: Job::Cancelled) + assert_equal Job::Cancelled, job.state + end + test "verify job queue position" do job1 = Job.create! job_attrs - assert job1.valid?, job1.errors.full_messages.to_s assert_equal 'Queued', job1.state, "Incorrect job state for newly created job1" job2 = Job.create! job_attrs - assert job2.valid?, job2.errors.full_messages.to_s assert_equal 'Queued', job2.state, "Incorrect job state for newly created job2" assert_not_nil job1.queue_position, "Expected non-nil queue position for job1" assert_not_nil job2.queue_position, "Expected non-nil queue position for job2" - assert_not_equal job1.queue_position, job2.queue_position end SDK_MASTER = "ca68b24e51992e790f29df5cc4bc54ce1da4a1c2" SDK_TAGGED = "00634b2b8a492d6f121e3cf1d6587b821136a9a7" def sdk_constraint(version) - {runtime_constraints: {"arvados_sdk_version" => version}} + {runtime_constraints: { + "arvados_sdk_version" => version, + "docker_image" => links(:docker_image_collection_tag).name, + }} end def check_job_sdk_version(expected) @@ -347,6 +394,23 @@ class JobTest < ActiveSupport::TestCase assert_nil(job.arvados_sdk_version) end + test "job with SDK constraint, without Docker image is invalid" do + sdk_attrs = sdk_constraint("master") + sdk_attrs[:runtime_constraints].delete("docker_image") + job = Job.create(job_attrs(sdk_attrs)) + refute(job.valid?, "Job valid with SDK version, without Docker image") + sdk_errors = job.errors.messages[:arvados_sdk_version] || [] + refute_empty(sdk_errors.grep(/\bDocker\b/), + "no Job SDK errors mention that Docker is required") + end + + test "invalid to clear Docker image constraint when SDK constraint exists" do + job = Job.create!(job_attrs(sdk_constraint("master"))) + job.runtime_constraints.delete("docker_image") + refute(job.valid?, + "Job with SDK constraint valid after clearing Docker image") + end + test "can't create job with SDK version assigned directly" do check_creation_prohibited(arvados_sdk_version: SDK_MASTER) end @@ -354,4 +418,88 @@ class JobTest < ActiveSupport::TestCase test "can't modify job to assign SDK version directly" do check_modification_prohibited(arvados_sdk_version: SDK_MASTER) end + + test "job validation fails when collection uuid found in script_parameters" do + bad_params = { + script_parameters: { + 'input' => { + 'param1' => 'the collection uuid zzzzz-4zz18-012345678901234' + } + } + } + assert_raises(ActiveRecord::RecordInvalid, + "created job with a collection uuid in script_parameters") do + Job.create!(job_attrs(bad_params)) + end + end + + test "job validation succeeds when no collection uuid in script_parameters" do + good_params = { + script_parameters: { + 'arg1' => 'foo', + 'arg2' => [ 'bar', 'baz' ], + 'arg3' => { + 'a' => 1, + 'b' => [2, 3, 4], + } + } + } + job = Job.create!(job_attrs(good_params)) + assert job.valid? + end + + test 'update job uuid tag in internal.git when version changes' do + authorize_with :active + j = jobs :queued + j.update_attributes repository: 'active/foo', script_version: 'b1' + assert_equal('1de84a854e2b440dc53bf42f8548afa4c17da332', + internal_tag(j.uuid)) + j.update_attributes repository: 'active/foo', script_version: 'master' + assert_equal('077ba2ad3ea24a929091a9e6ce545c93199b8e57', + internal_tag(j.uuid)) + end + + test 'script_parameters_digest is independent of key order' do + j1 = Job.new(job_attrs(script_parameters: {'a' => 'a', 'ddee' => {'d' => 'd', 'e' => 'e'}})) + j2 = Job.new(job_attrs(script_parameters: {'ddee' => {'e' => 'e', 'd' => 'd'}, 'a' => 'a'})) + assert j1.valid? + assert j2.valid? + assert_equal(j1.script_parameters_digest, j2.script_parameters_digest) + end + + test 'job fixtures have correct script_parameters_digest' do + Job.all.each do |j| + d = j.script_parameters_digest + assert_equal(j.update_script_parameters_digest, d, + "wrong script_parameters_digest for #{j.uuid}") + end + end + + test 'deep_sort_hash on array of hashes' do + a = {'z' => [[{'a' => 'a', 'b' => 'b'}]]} + b = {'z' => [[{'b' => 'b', 'a' => 'a'}]]} + assert_equal Job.deep_sort_hash(a).to_json, Job.deep_sort_hash(b).to_json + end + + test 'find_reusable' do + foobar = jobs(:foobar) + example_attrs = { + script_version: foobar.script_version, + script: foobar.script, + script_parameters: foobar.script_parameters, + repository: foobar.repository, + } + + # Two matching jobs exist with identical outputs. The older one + # should be reused. + j = Job.find_reusable(example_attrs, {}, [], [users(:active)]) + assert j + assert_equal foobar.uuid, j.uuid + + # Two matching jobs exist with different outputs. Neither should + # be reused. + Job.where(uuid: jobs(:job_with_latest_version).uuid). + update_all(output: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+1') + assert_nil Job.find_reusable(example_attrs, {}, [], [users(:active)]) + end end