services/api/test/functional/arvados/v1/container_requests_controller_test.rb

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: AGPL-3.0
   4
   5 require 'test_helper'
   6
   7 class Arvados::V1::ContainerRequestsControllerTest < ActionController::TestCase
   8   def minimal_cr
   9     {
  10       command: ['echo', 'hello'],
  11       container_image: 'test',
  12       output_path: 'test',
  13     }
  14   end
  15
  16   test 'create with scheduling parameters' do
  17     authorize_with :active
  18
  19     sp = {'partitions' => ['test1', 'test2']}
  20     post :create, params: {
  21            container_request: minimal_cr.merge(scheduling_parameters: sp.dup)
  22          }
  23     assert_response :success
  24
  25     cr = JSON.parse(@response.body)
  26     assert_not_nil cr, 'Expected container request'
  27     assert_equal sp['partitions'], cr['scheduling_parameters']['partitions']
  28     assert_equal false, cr['scheduling_parameters']['preemptible']
  29   end
  30
  31   test "secret_mounts not in #create responses" do
  32     authorize_with :active
  33
  34     post :create, params: {
  35            container_request: minimal_cr.merge(
  36              secret_mounts: {'/foo' => {'kind' => 'json', 'content' => 'bar'}}),
  37          }
  38     assert_response :success
  39
  40     resp = JSON.parse(@response.body)
  41     refute resp.has_key?('secret_mounts')
  42
  43     req = ContainerRequest.where(uuid: resp['uuid']).first
  44     assert_equal 'bar', req.secret_mounts['/foo']['content']
  45   end
  46
  47   test "update with secret_mounts" do
  48     authorize_with :active
  49     req = container_requests(:uncommitted)
  50
  51     patch :update, params: {
  52             id: req.uuid,
  53             container_request: {
  54               secret_mounts: {'/foo' => {'kind' => 'json', 'content' => 'bar'}},
  55             },
  56           }
  57     assert_response :success
  58
  59     resp = JSON.parse(@response.body)
  60     refute resp.has_key?('secret_mounts')
  61
  62     req.reload
  63     assert_equal 'bar', req.secret_mounts['/foo']['content']
  64   end
  65
  66   test "cancel with runtime_constraints and scheduling_params with default values" do
  67     authorize_with :active
  68     req = container_requests(:queued)
  69
  70     patch :update, params: {
  71       id: req.uuid,
  72       container_request: {
  73         state: 'Final',
  74         priority: 0,
  75         runtime_constraints: {
  76           'vcpus' => 1,
  77           'ram' => 123,
  78           'keep_cache_ram' => 0,
  79         },
  80         scheduling_parameters: {
  81           "preemptible"=>false
  82         }
  83       },
  84     }
  85     assert_response :success
  86   end
  87
  88   test "update without deleting secret_mounts" do
  89     authorize_with :active
  90     req = container_requests(:uncommitted)
  91     req.update_attributes!(secret_mounts: {'/foo' => {'kind' => 'json', 'content' => 'bar'}})
  92
  93     patch :update, params: {
  94             id: req.uuid,
  95             container_request: {
  96               command: ['echo', 'test'],
  97             },
  98           }
  99     assert_response :success
 100
 101     resp = JSON.parse(@response.body)
 102     refute resp.has_key?('secret_mounts')
 103
 104     req.reload
 105     assert_equal 'bar', req.secret_mounts['/foo']['content']
 106   end
 107
 108   test "runtime_token not in #create responses" do
 109     authorize_with :active
 110
 111     post :create, params: {
 112            container_request: minimal_cr.merge(
 113              runtime_token: api_client_authorizations(:spectator).token)
 114          }
 115     assert_response :success
 116
 117     resp = JSON.parse(@response.body)
 118     refute resp.has_key?('runtime_token')
 119
 120     req = ContainerRequest.where(uuid: resp['uuid']).first
 121     assert_equal api_client_authorizations(:spectator).token, req.runtime_token
 122   end
 123
 124   %w(Running Complete).each do |state|
 125     test "filter on container.state = #{state}" do
 126       authorize_with :active
 127       get :index, params: {
 128             filters: [['container.state', '=', state]],
 129           }
 130       assert_response :success
 131       assert_operator json_response['items'].length, :>, 0
 132       json_response['items'].each do |cr|
 133         assert_equal state, Container.find_by_uuid(cr['container_uuid']).state
 134       end
 135     end
 136   end
 137
 138   test "filter on container success" do
 139     authorize_with :active
 140     get :index, params: {
 141           filters: [
 142             ['container.state', '=', 'Complete'],
 143             ['container.exit_code', '=', '0'],
 144           ],
 145         }
 146     assert_response :success
 147     assert_operator json_response['items'].length, :>, 0
 148     json_response['items'].each do |cr|
 149       assert_equal 'Complete', Container.find_by_uuid(cr['container_uuid']).state
 150       assert_equal 0, Container.find_by_uuid(cr['container_uuid']).exit_code
 151     end
 152   end
 153
 154   test "filter on container subproperty runtime_status[foo] = bar" do
 155     ctr = containers(:running)
 156     act_as_system_user do
 157       ctr.update_attributes!(runtime_status: {foo: 'bar'})
 158     end
 159     authorize_with :active
 160     get :index, params: {
 161           filters: [
 162             ['container.runtime_status.foo', '=', 'bar'],
 163           ],
 164         }
 165     assert_response :success
 166     assert_equal [ctr.uuid], json_response['items'].collect { |cr| cr['container_uuid'] }.uniq
 167   end
 168 end