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

   1 require 'test_helper'
   2
   3 class Arvados::V1::LinksControllerTest < ActionController::TestCase
   4
   5   test "no symbol keys in serialized hash" do
   6     link = {
   7       properties: {username: 'testusername'},
   8       link_class: 'test',
   9       name: 'encoding',
  10       tail_uuid: users(:admin).uuid,
  11       head_uuid: virtual_machines(:testvm).uuid
  12     }
  13     authorize_with :admin
  14     [link, link.to_json].each do |formatted_link|
  15       post :create, link: formatted_link
  16       assert_response :success
  17       assert_not_nil assigns(:object)
  18       assert_equal 'testusername', assigns(:object).properties['username']
  19       assert_equal false, assigns(:object).properties.has_key?(:username)
  20     end
  21   end
  22
  23   test "head must exist" do
  24     link = {
  25       link_class: 'test',
  26       name: 'stuff',
  27       tail_uuid: users(:active).uuid,
  28       head_uuid: 'zzzzz-tpzed-xyzxyzxerrrorxx'
  29     }
  30     authorize_with :admin
  31     post :create, link: link
  32     assert_response 422
  33   end
  34
  35   test "tail must exist" do
  36     link = {
  37       link_class: 'test',
  38       name: 'stuff',
  39       head_uuid: users(:active).uuid,
  40       tail_uuid: 'zzzzz-tpzed-xyzxyzxerrrorxx'
  41     }
  42     authorize_with :admin
  43     post :create, link: link
  44     assert_response 422
  45   end
  46
  47   test "head and tail exist, head_kind and tail_kind are returned" do
  48     link = {
  49       link_class: 'test',
  50       name: 'stuff',
  51       head_uuid: users(:active).uuid,
  52       tail_uuid: users(:spectator).uuid,
  53     }
  54     authorize_with :admin
  55     post :create, link: link
  56     assert_response :success
  57     l = JSON.parse(@response.body)
  58     assert 'arvados#user', l['head_kind']
  59     assert 'arvados#user', l['tail_kind']
  60   end
  61
  62   test "can supply head_kind and tail_kind without error" do
  63     link = {
  64       link_class: 'test',
  65       name: 'stuff',
  66       head_uuid: users(:active).uuid,
  67       tail_uuid: users(:spectator).uuid,
  68       head_kind: "arvados#user",
  69       tail_kind: "arvados#user",
  70     }
  71     authorize_with :admin
  72     post :create, link: link
  73     assert_response :success
  74     l = JSON.parse(@response.body)
  75     assert 'arvados#user', l['head_kind']
  76     assert 'arvados#user', l['tail_kind']
  77   end
  78
  79   test "tail must be visible by user" do
  80     link = {
  81       link_class: 'test',
  82       name: 'stuff',
  83       head_uuid: users(:active).uuid,
  84       tail_uuid: virtual_machines(:testvm).uuid
  85     }
  86     authorize_with :active
  87     post :create, link: link
  88     assert_response 422
  89   end
  90
  91   test "filter links with 'is_a' operator" do
  92     authorize_with :admin
  93     get :index, {
  94       filters: [ ['tail_uuid', 'is_a', 'arvados#user'] ]
  95     }
  96     assert_response :success
  97     found = assigns(:objects)
  98     assert_not_equal 0, found.count
  99     assert_equal found.count, (found.select { |f| f.tail_uuid.match /[a-z0-9]{5}-tpzed-[a-z0-9]{15}/}).count
 100   end
 101
 102   test "filter links with 'is_a' operator with more than one" do
 103     authorize_with :admin
 104     get :index, {
 105       filters: [ ['tail_uuid', 'is_a', ['arvados#user', 'arvados#group'] ] ],
 106     }
 107     assert_response :success
 108     found = assigns(:objects)
 109     assert_not_equal 0, found.count
 110     assert_equal found.count, (found.select { |f| f.tail_uuid.match /[a-z0-9]{5}-(tpzed|j7d0g)-[a-z0-9]{15}/}).count
 111   end
 112
 113   test "filter links with 'is_a' operator with bogus type" do
 114     authorize_with :admin
 115     get :index, {
 116       filters: [ ['tail_uuid', 'is_a', ['arvados#bogus'] ] ],
 117     }
 118     assert_response :success
 119     found = assigns(:objects)
 120     assert_equal 0, found.count
 121   end
 122
 123   test "filter links with 'is_a' operator with collection" do
 124     authorize_with :admin
 125     get :index, {
 126       filters: [ ['head_uuid', 'is_a', ['arvados#collection'] ] ],
 127     }
 128     assert_response :success
 129     found = assigns(:objects)
 130     assert_not_equal 0, found.count
 131     assert_equal found.count, (found.select { |f| f.head_uuid.match /[a-f0-9]{32}\+\d+/}).count
 132   end
 133
 134   test "test can still use where tail_kind" do
 135     authorize_with :admin
 136     get :index, {
 137       where: { tail_kind: 'arvados#user' }
 138     }
 139     assert_response :success
 140     found = assigns(:objects)
 141     assert_not_equal 0, found.count
 142     assert_equal found.count, (found.select { |f| f.tail_uuid.match /[a-z0-9]{5}-tpzed-[a-z0-9]{15}/}).count
 143   end
 144
 145   test "test can still use where head_kind" do
 146     authorize_with :admin
 147     get :index, {
 148       where: { head_kind: 'arvados#user' }
 149     }
 150     assert_response :success
 151     found = assigns(:objects)
 152     assert_not_equal 0, found.count
 153     assert_equal found.count, (found.select { |f| f.head_uuid.match /[a-z0-9]{5}-tpzed-[a-z0-9]{15}/}).count
 154   end
 155
 156   test "test can still use filter tail_kind" do
 157     authorize_with :admin
 158     get :index, {
 159       filters: [ ['tail_kind', '=', 'arvados#user'] ]
 160     }
 161     assert_response :success
 162     found = assigns(:objects)
 163     assert_not_equal 0, found.count
 164     assert_equal found.count, (found.select { |f| f.tail_uuid.match /[a-z0-9]{5}-tpzed-[a-z0-9]{15}/}).count
 165   end
 166
 167   test "test can still use filter head_kind" do
 168     authorize_with :admin
 169     get :index, {
 170       filters: [ ['head_kind', '=', 'arvados#user'] ]
 171     }
 172     assert_response :success
 173     found = assigns(:objects)
 174     assert_not_equal 0, found.count
 175     assert_equal found.count, (found.select { |f| f.head_uuid.match /[a-z0-9]{5}-tpzed-[a-z0-9]{15}/}).count
 176   end
 177
 178   test "head_kind matches head_uuid" do
 179     link = {
 180       link_class: 'test',
 181       name: 'stuff',
 182       head_uuid: groups(:public).uuid,
 183       head_kind: "arvados#user",
 184       tail_uuid: users(:spectator).uuid,
 185       tail_kind: "arvados#user",
 186     }
 187     authorize_with :admin
 188     post :create, link: link
 189     assert_response 422
 190   end
 191
 192   test "tail_kind matches tail_uuid" do
 193     link = {
 194       link_class: 'test',
 195       name: 'stuff',
 196       head_uuid: users(:active).uuid,
 197       head_kind: "arvados#user",
 198       tail_uuid: groups(:public).uuid,
 199       tail_kind: "arvados#user",
 200     }
 201     authorize_with :admin
 202     post :create, link: link
 203     assert_response 422
 204   end
 205
 206   test "test with virtual_machine" do
 207     link = {
 208       tail_kind: "arvados#user",
 209       tail_uuid: users(:active).uuid,
 210       head_kind: "arvados#virtual_machine",
 211       head_uuid: virtual_machines(:testvm).uuid,
 212       link_class: "permission",
 213       name: "can_login",
 214       properties: {username: "repo_and_user_name"}
 215     }
 216     authorize_with :admin
 217     post :create, link: link
 218     assert_response 422
 219   end
 220
 221   test "test with virtualMachine" do
 222     link = {
 223       tail_kind: "arvados#user",
 224       tail_uuid: users(:active).uuid,
 225       head_kind: "arvados#virtualMachine",
 226       head_uuid: virtual_machines(:testvm).uuid,
 227       link_class: "permission",
 228       name: "can_login",
 229       properties: {username: "repo_and_user_name"}
 230     }
 231     authorize_with :admin
 232     post :create, link: link
 233     assert_response :success
 234   end
 235
 236 end