services/api/test/functional/arvados/v1/filters_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::FiltersTest < ActionController::TestCase
   8   test '"not in" filter passes null values' do
   9     @controller = Arvados::V1::GroupsController.new
  10     authorize_with :admin
  11     get :index, params: {
  12       filters: [ ['group_class', 'not in', ['project']] ],
  13       controller: 'groups',
  14     }
  15     assert_response :success
  16     found = assigns(:objects)
  17     assert_includes(found.collect(&:group_class), nil,
  18                     "'group_class not in ['project']' filter should pass null")
  19   end
  20
  21   test 'error message for non-array element in filters array' do
  22     @controller = Arvados::V1::CollectionsController.new
  23     authorize_with :active
  24     get :index, params: {
  25       filters: [{bogus: 'filter'}],
  26     }
  27     assert_response 422
  28     assert_match(/Invalid element in filters array/,
  29                  json_response['errors'].join(' '))
  30   end
  31
  32   test 'error message for full text search on a specific column' do
  33     @controller = Arvados::V1::CollectionsController.new
  34     authorize_with :active
  35     get :index, params: {
  36       filters: [['uuid', '@@', 'abcdef']],
  37     }
  38     assert_response 422
  39     assert_match(/not supported/, json_response['errors'].join(' '))
  40   end
  41
  42   test 'difficult characters in full text search' do
  43     @controller = Arvados::V1::CollectionsController.new
  44     authorize_with :active
  45     get :index, params: {
  46       filters: [['any', '@@', 'a|b"c']],
  47     }
  48     assert_response :success
  49     # (Doesn't matter so much which results are returned.)
  50   end
  51
  52   test 'array operand in full text search' do
  53     @controller = Arvados::V1::CollectionsController.new
  54     authorize_with :active
  55     get :index, params: {
  56       filters: [['any', '@@', ['abc', 'def']]],
  57     }
  58     assert_response 422
  59     assert_match(/not supported/, json_response['errors'].join(' '))
  60   end
  61
  62   test 'api responses provide timestamps with nanoseconds' do
  63     @controller = Arvados::V1::CollectionsController.new
  64     authorize_with :active
  65     get :index
  66     assert_response :success
  67     assert_not_empty json_response['items']
  68     json_response['items'].each do |item|
  69       %w(created_at modified_at).each do |attr|
  70         # Pass fixtures with null timestamps.
  71         next if item[attr].nil?
  72         assert_match(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d.\d{9}Z$/, item[attr])
  73       end
  74     end
  75   end
  76
  77   %w(< > <= >= =).each do |operator|
  78     test "timestamp #{operator} filters work with nanosecond precision" do
  79       # Python clients like Node Manager rely on this exact format.
  80       # If you must change this format for some reason, make sure you
  81       # coordinate the change with them.
  82       expect_match = !!operator.index('=')
  83       mine = act_as_user users(:active) do
  84         Collection.create!(manifest_text: '')
  85       end
  86       timestamp = mine.modified_at.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
  87       @controller = Arvados::V1::CollectionsController.new
  88       authorize_with :active
  89       get :index, params: {
  90         filters: [['modified_at', operator, timestamp],
  91                   ['uuid', '=', mine.uuid]],
  92       }
  93       assert_response :success
  94       uuids = json_response['items'].map { |item| item['uuid'] }
  95       if expect_match
  96         assert_includes uuids, mine.uuid
  97       else
  98         assert_not_includes uuids, mine.uuid
  99       end
 100     end
 101   end
 102
 103   test "full text search with count='none'" do
 104     @controller = Arvados::V1::GroupsController.new
 105     authorize_with :admin
 106
 107     get :contents, params: {
 108       format: :json,
 109       count: 'none',
 110       limit: 1000,
 111       filters: [['any', '@@', Rails.configuration.ClusterID]],
 112     }
 113
 114     assert_response :success
 115
 116     all_objects = Hash.new(0)
 117     json_response['items'].map{|o| o['kind']}.each{|t| all_objects[t] += 1}
 118
 119     assert_equal true, all_objects['arvados#group']>0
 120     assert_equal true, all_objects['arvados#job']>0
 121     assert_equal true, all_objects['arvados#pipelineInstance']>0
 122     assert_equal true, all_objects['arvados#pipelineTemplate']>0
 123
 124     # Perform test again mimicking a second page request with:
 125     # last_object_class = PipelineInstance
 126     #   and hence groups and jobs should not be included in the response
 127     # offset = 5, which means first 5 pipeline instances were already received in page 1
 128     #   and hence the remaining pipeline instances and all other object types should be included in the response
 129
 130     @test_counter = 0  # Reset executed action counter
 131
 132     @controller = Arvados::V1::GroupsController.new
 133
 134     get :contents, params: {
 135       format: :json,
 136       count: 'none',
 137       limit: 1000,
 138       offset: '5',
 139       last_object_class: 'PipelineInstance',
 140       filters: [['any', '@@', Rails.configuration.ClusterID]],
 141     }
 142
 143     assert_response :success
 144
 145     second_page = Hash.new(0)
 146     json_response['items'].map{|o| o['kind']}.each{|t| second_page[t] += 1}
 147
 148     assert_equal false, second_page.include?('arvados#group')
 149     assert_equal false, second_page.include?('arvados#job')
 150     assert_equal true, second_page['arvados#pipelineInstance']>0
 151     assert_equal all_objects['arvados#pipelineInstance'], second_page['arvados#pipelineInstance']+5
 152     assert_equal true, second_page['arvados#pipelineTemplate']>0
 153   end
 154
 155   [['prop1', '=', 'value1', [:collection_with_prop1_value1], [:collection_with_prop1_value2, :collection_with_prop2_1]],
 156    ['prop1', '!=', 'value1', [:collection_with_prop1_value2, :collection_with_prop2_1], [:collection_with_prop1_value1]],
 157    ['prop1', 'exists', true, [:collection_with_prop1_value1, :collection_with_prop1_value2, :collection_with_prop1_value3, :collection_with_prop1_other1], [:collection_with_prop2_1]],
 158    ['prop1', 'exists', false, [:collection_with_prop2_1], [:collection_with_prop1_value1, :collection_with_prop1_value2, :collection_with_prop1_value3, :collection_with_prop1_other1]],
 159    ['prop1', 'in', ['value1', 'value2'], [:collection_with_prop1_value1, :collection_with_prop1_value2], [:collection_with_prop1_value3, :collection_with_prop2_1]],
 160    ['prop1', 'in', ['value1', 'valueX'], [:collection_with_prop1_value1], [:collection_with_prop1_value3, :collection_with_prop2_1]],
 161    ['prop1', 'not in', ['value1', 'value2'], [:collection_with_prop1_value3, :collection_with_prop1_other1, :collection_with_prop2_1], [:collection_with_prop1_value1, :collection_with_prop1_value2]],
 162    ['prop1', 'not in', ['value1', 'valueX'], [:collection_with_prop1_value2, :collection_with_prop1_value3, :collection_with_prop1_other1, :collection_with_prop2_1], [:collection_with_prop1_value1]],
 163    ['prop1', '>', 'value2', [:collection_with_prop1_value3], [:collection_with_prop1_other1, :collection_with_prop1_value1]],
 164    ['prop1', '<', 'value2', [:collection_with_prop1_other1, :collection_with_prop1_value1], [:collection_with_prop1_value2, :collection_with_prop1_value2]],
 165    ['prop1', '<=', 'value2', [:collection_with_prop1_other1, :collection_with_prop1_value1, :collection_with_prop1_value2], [:collection_with_prop1_value3]],
 166    ['prop1', '>=', 'value2', [:collection_with_prop1_value2, :collection_with_prop1_value3], [:collection_with_prop1_other1, :collection_with_prop1_value1]],
 167    ['prop1', 'like', 'value%', [:collection_with_prop1_value1, :collection_with_prop1_value2, :collection_with_prop1_value3], [:collection_with_prop1_other1]],
 168    ['prop1', 'like', '%1', [:collection_with_prop1_value1, :collection_with_prop1_other1], [:collection_with_prop1_value2, :collection_with_prop1_value3]],
 169    ['prop1', 'ilike', 'VALUE%', [:collection_with_prop1_value1, :collection_with_prop1_value2, :collection_with_prop1_value3], [:collection_with_prop1_other1]],
 170    ['prop2', '>',  1, [:collection_with_prop2_5], [:collection_with_prop2_1]],
 171    ['prop2', '<',  5, [:collection_with_prop2_1], [:collection_with_prop2_5]],
 172    ['prop2', '<=', 5, [:collection_with_prop2_1, :collection_with_prop2_5], []],
 173    ['prop2', '>=', 1, [:collection_with_prop2_1, :collection_with_prop2_5], []],
 174    ['<http://schema.org/example>', '=', "value1", [:collection_with_uri_prop], []],
 175    ['listprop', 'contains', 'elem1', [:collection_with_list_prop_odd, :collection_with_listprop_elem1], [:collection_with_list_prop_even]],
 176    ['listprop', 'contains', 5, [:collection_with_list_prop_odd], [:collection_with_list_prop_even, :collection_with_listprop_elem1]],
 177    ['listprop', 'contains', 'elem2', [:collection_with_list_prop_even], [:collection_with_list_prop_odd, :collection_with_listprop_elem1]],
 178    ['listprop', 'contains', 4, [:collection_with_list_prop_even], [:collection_with_list_prop_odd, :collection_with_listprop_elem1]],
 179   ].each do |prop, op, opr, inc, ex|
 180     test "jsonb filter properties.#{prop} #{op} #{opr})" do
 181       @controller = Arvados::V1::CollectionsController.new
 182       authorize_with :admin
 183       get :index, params: {
 184             filters: SafeJSON.dump([ ["properties.#{prop}", op, opr] ]),
 185             limit: 1000
 186           }
 187       assert_response :success
 188       found = assigns(:objects).collect(&:uuid)
 189
 190       inc.each do |i|
 191         assert_includes(found, collections(i).uuid)
 192       end
 193
 194       ex.each do |e|
 195         assert_not_includes(found, collections(e).uuid)
 196       end
 197     end
 198   end
 199
 200   test "jsonb hash 'exists' and '!=' filter" do
 201     @controller = Arvados::V1::CollectionsController.new
 202     authorize_with :admin
 203     get :index, params: {
 204       filters: [ ['properties.prop1', 'exists', true], ['properties.prop1', '!=', 'value1'] ]
 205     }
 206     assert_response :success
 207     found = assigns(:objects).collect(&:uuid)
 208     assert_equal found.length, 3
 209     assert_not_includes(found, collections(:collection_with_prop1_value1).uuid)
 210     assert_includes(found, collections(:collection_with_prop1_value2).uuid)
 211     assert_includes(found, collections(:collection_with_prop1_value3).uuid)
 212     assert_includes(found, collections(:collection_with_prop1_other1).uuid)
 213   end
 214
 215   test "jsonb array 'exists'" do
 216     @controller = Arvados::V1::CollectionsController.new
 217     authorize_with :admin
 218     get :index, params: {
 219       filters: [ ['storage_classes_confirmed.default', 'exists', true] ]
 220     }
 221     assert_response :success
 222     found = assigns(:objects).collect(&:uuid)
 223     assert_equal 2, found.length
 224     assert_not_includes(found,
 225       collections(:storage_classes_desired_default_unconfirmed).uuid)
 226     assert_includes(found,
 227       collections(:storage_classes_desired_default_confirmed_default).uuid)
 228     assert_includes(found,
 229       collections(:storage_classes_desired_archive_confirmed_default).uuid)
 230   end
 231
 232   test "jsonb hash alternate form 'exists' and '!=' filter" do
 233     @controller = Arvados::V1::CollectionsController.new
 234     authorize_with :admin
 235     get :index, params: {
 236       filters: [ ['properties', 'exists', 'prop1'], ['properties.prop1', '!=', 'value1'] ]
 237     }
 238     assert_response :success
 239     found = assigns(:objects).collect(&:uuid)
 240     assert_equal found.length, 3
 241     assert_not_includes(found, collections(:collection_with_prop1_value1).uuid)
 242     assert_includes(found, collections(:collection_with_prop1_value2).uuid)
 243     assert_includes(found, collections(:collection_with_prop1_value3).uuid)
 244     assert_includes(found, collections(:collection_with_prop1_other1).uuid)
 245   end
 246
 247   test "jsonb array alternate form 'exists' filter" do
 248     @controller = Arvados::V1::CollectionsController.new
 249     authorize_with :admin
 250     get :index, params: {
 251       filters: [ ['storage_classes_confirmed', 'exists', 'default'] ]
 252     }
 253     assert_response :success
 254     found = assigns(:objects).collect(&:uuid)
 255     assert_equal 2, found.length
 256     assert_not_includes(found,
 257       collections(:storage_classes_desired_default_unconfirmed).uuid)
 258     assert_includes(found,
 259       collections(:storage_classes_desired_default_confirmed_default).uuid)
 260     assert_includes(found,
 261       collections(:storage_classes_desired_archive_confirmed_default).uuid)
 262   end
 263
 264   test "jsonb 'exists' must be boolean" do
 265     @controller = Arvados::V1::CollectionsController.new
 266     authorize_with :admin
 267     get :index, params: {
 268       filters: [ ['properties.prop1', 'exists', nil] ]
 269     }
 270     assert_response 422
 271     assert_match(/Invalid operand '' for 'exists' must be true or false/,
 272                  json_response['errors'].join(' '))
 273   end
 274
 275   test "jsonb checks column exists" do
 276     @controller = Arvados::V1::CollectionsController.new
 277     authorize_with :admin
 278     get :index, params: {
 279       filters: [ ['puppies.prop1', '=', 'value1'] ]
 280     }
 281     assert_response 422
 282     assert_match(/Invalid attribute 'puppies' for subproperty filter/,
 283                  json_response['errors'].join(' '))
 284   end
 285
 286   test "jsonb checks column is valid" do
 287     @controller = Arvados::V1::CollectionsController.new
 288     authorize_with :admin
 289     get :index, params: {
 290       filters: [ ['name.prop1', '=', 'value1'] ]
 291     }
 292     assert_response 422
 293     assert_match(/Invalid attribute 'name' for subproperty filter/,
 294                  json_response['errors'].join(' '))
 295   end
 296
 297   test "jsonb invalid operator" do
 298     @controller = Arvados::V1::CollectionsController.new
 299     authorize_with :admin
 300     get :index, params: {
 301       filters: [ ['properties.prop1', '###', 'value1'] ]
 302     }
 303     assert_response 422
 304     assert_match(/Invalid operator for subproperty search '###'/,
 305                  json_response['errors'].join(' '))
 306   end
 307
 308   test "replication_desired = 2" do
 309     @controller = Arvados::V1::CollectionsController.new
 310     authorize_with :admin
 311     get :index, params: {
 312       filters: SafeJSON.dump([ ['replication_desired', '=', 2] ])
 313     }
 314     assert_response :success
 315     found = assigns(:objects).collect(&:uuid)
 316     assert_includes(found, collections(:replication_desired_2_unconfirmed).uuid)
 317     assert_includes(found, collections(:replication_desired_2_confirmed_2).uuid)
 318   end
 319 end