apps/workbench/test/controllers/projects_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 require 'helpers/share_object_helper'
   7
   8 class ProjectsControllerTest < ActionController::TestCase
   9   include ShareObjectHelper
  10
  11   test "invited user is asked to sign user agreements on front page" do
  12     get :index, params: {}, session: session_for(:inactive)
  13     assert_response :redirect
  14     assert_match(/^#{Regexp.escape(user_agreements_url)}\b/,
  15                  @response.redirect_url,
  16                  "Inactive user was not redirected to user_agreements page")
  17   end
  18
  19   test "uninvited user is asked to wait for activation" do
  20     get :index, params: {}, session: session_for(:inactive_uninvited)
  21     assert_response :redirect
  22     assert_match(/^#{Regexp.escape(inactive_users_url)}\b/,
  23                  @response.redirect_url,
  24                  "Uninvited user was not redirected to inactive user page")
  25   end
  26
  27   [[:active, true],
  28    [:project_viewer, false]].each do |which_user, should_show|
  29     test "create subproject button #{'not ' unless should_show} shown to #{which_user}" do
  30       readonly_project_uuid = api_fixture('groups')['aproject']['uuid']
  31       get :show, params: {
  32         id: readonly_project_uuid
  33       }, session: session_for(which_user)
  34       buttons = css_select('[data-method=post]').select do |el|
  35         el.attributes['data-remote-href'].value.match /project.*owner_uuid.*#{readonly_project_uuid}/
  36       end
  37       if should_show
  38         assert_not_empty(buttons, "did not offer to create a subproject")
  39       else
  40         assert_empty(buttons.collect(&:to_s),
  41                      "offered to create a subproject in a non-writable project")
  42       end
  43     end
  44   end
  45
  46   test "sharing a project with a user and group" do
  47     uuid_list = [api_fixture("groups")["future_project_viewing_group"]["uuid"],
  48                  api_fixture("users")["future_project_user"]["uuid"]]
  49     post(:share_with, params: {
  50            id: api_fixture("groups")["asubproject"]["uuid"],
  51            uuids: uuid_list,
  52            format: "json"},
  53          session: session_for(:active))
  54     assert_response :success
  55     assert_equal(uuid_list, json_response["success"])
  56   end
  57
  58   test "user with project read permission can't add permissions" do
  59     share_uuid = api_fixture("users")["spectator"]["uuid"]
  60     post(:share_with, params: {
  61            id: api_fixture("groups")["aproject"]["uuid"],
  62            uuids: [share_uuid],
  63            format: "json"},
  64          session: session_for(:project_viewer))
  65     assert_response 422
  66     assert(json_response["errors"].andand.
  67              any? { |msg| msg.start_with?("#{share_uuid}: ") },
  68            "JSON response missing properly formatted sharing error")
  69   end
  70
  71   test "admin can_manage aproject" do
  72     assert user_can_manage(:admin, api_fixture("groups")["aproject"])
  73   end
  74
  75   test "owner can_manage aproject" do
  76     assert user_can_manage(:active, api_fixture("groups")["aproject"])
  77   end
  78
  79   test "owner can_manage asubproject" do
  80     assert user_can_manage(:active, api_fixture("groups")["asubproject"])
  81   end
  82
  83   test "viewer can't manage aproject" do
  84     refute user_can_manage(:project_viewer, api_fixture("groups")["aproject"])
  85   end
  86
  87   test "viewer can't manage asubproject" do
  88     refute user_can_manage(:project_viewer, api_fixture("groups")["asubproject"])
  89   end
  90
  91   test "subproject_admin can_manage asubproject" do
  92     assert user_can_manage(:subproject_admin, api_fixture("groups")["asubproject"])
  93   end
  94
  95   test "detect ownership loop in project breadcrumbs" do
  96     # This test has an arbitrary time limit -- otherwise we'd just sit
  97     # here forever instead of reporting that the loop was not
  98     # detected. The test passes quickly, but fails slowly.
  99     Timeout::timeout 10 do
 100       get(:show,
 101           params: { id: api_fixture("groups")["project_owns_itself"]["uuid"] },
 102           session: session_for(:admin))
 103     end
 104     assert_response :success
 105   end
 106
 107   test "project admin can remove collections from the project" do
 108     # Deleting an object that supports 'trash_at' should make it
 109     # completely inaccessible to API queries, not simply moved out of
 110     # the project.
 111     coll_key = "collection_to_remove_from_subproject"
 112     coll_uuid = api_fixture("collections")[coll_key]["uuid"]
 113     delete(:remove_item,
 114            params: { id: api_fixture("groups")["asubproject"]["uuid"],
 115              item_uuid: coll_uuid,
 116              format: "js" },
 117            session: session_for(:subproject_admin))
 118     assert_response :success
 119     assert_match(/\b#{coll_uuid}\b/, @response.body,
 120                  "removed object not named in response")
 121
 122     use_token :subproject_admin
 123     assert_raise ArvadosApiClient::NotFoundException do
 124       Collection.find(coll_uuid, cache: false)
 125     end
 126   end
 127
 128   test "project admin can remove items from project other than collections" do
 129     # An object which does not have an trash_at field (e.g. Specimen)
 130     # should be implicitly moved to the user's Home project when removed.
 131     specimen_uuid = api_fixture('specimens', 'in_asubproject')['uuid']
 132     delete(:remove_item,
 133            params: { id: api_fixture('groups', 'asubproject')['uuid'],
 134              item_uuid: specimen_uuid,
 135              format: 'js' },
 136            session: session_for(:subproject_admin))
 137     assert_response :success
 138     assert_match(/\b#{specimen_uuid}\b/, @response.body,
 139                  "removed object not named in response")
 140
 141     use_token :subproject_admin
 142     new_specimen = Specimen.find(specimen_uuid)
 143     assert_equal api_fixture('users', 'subproject_admin')['uuid'], new_specimen.owner_uuid
 144   end
 145
 146   test 'projects#show tab infinite scroll partial obeys limit' do
 147     get_contents_rows(limit: 1, filters: [['uuid','is_a',['arvados#job']]])
 148     assert_response :success
 149     assert_equal(1, json_response['content'].scan('<tr').count,
 150                  "Did not get exactly one row")
 151   end
 152
 153   ['', ' asc', ' desc'].each do |direction|
 154     test "projects#show tab partial orders correctly by created_at#{direction}" do
 155       _test_tab_content_order direction
 156     end
 157   end
 158
 159   def _test_tab_content_order direction
 160     get_contents_rows(limit: 100,
 161                       order: "created_at#{direction}",
 162                       filters: [['uuid','is_a',['arvados#job',
 163                                                 'arvados#pipelineInstance']]])
 164     assert_response :success
 165     not_grouped_by_kind = nil
 166     last_timestamp = nil
 167     last_kind = nil
 168     found_kind = {}
 169     json_response['content'].scan /<tr[^>]+>/ do |tr_tag|
 170       found_timestamps = 0
 171       tr_tag.scan(/\ data-object-created-at=\"(.*?)\"/).each do |t,|
 172         if last_timestamp
 173           correct_operator = / desc$/ =~ direction ? :>= : :<=
 174           assert_operator(last_timestamp, correct_operator, t,
 175                           "Rows are not sorted by created_at#{direction}")
 176         end
 177         last_timestamp = t
 178         found_timestamps += 1
 179       end
 180       assert_equal(1, found_timestamps,
 181                    "Content row did not have exactly one timestamp")
 182
 183       # Confirm that the test for timestamp ordering couldn't have
 184       # passed merely because the test fixtures have convenient
 185       # timestamps (e.g., there is only one pipeline and one job in
 186       # the project being tested, or there are no pipelines at all in
 187       # the project being tested):
 188       tr_tag.scan /\ data-kind=\"(.*?)\"/ do |kind|
 189         if last_kind and last_kind != kind and found_kind[kind]
 190           # We saw this kind before, then a different kind, then
 191           # this kind again. That means objects are not grouped by
 192           # kind.
 193           not_grouped_by_kind = true
 194         end
 195         found_kind[kind] ||= 0
 196         found_kind[kind] += 1
 197         last_kind = kind
 198       end
 199     end
 200     assert_equal(true, not_grouped_by_kind,
 201                  "Could not confirm that results are not grouped by kind")
 202   end
 203
 204   def get_contents_rows params
 205     params = {
 206       id: api_fixture('users')['active']['uuid'],
 207       partial: :contents_rows,
 208       format: :json,
 209     }.merge(params)
 210     encoded_params = Hash[params.map { |k,v|
 211                             [k, (v.is_a?(Array) || v.is_a?(Hash)) ? v.to_json : v]
 212                           }]
 213     get :show, params: encoded_params, session: session_for(:active)
 214   end
 215
 216   test "visit non-public project as anonymous when anonymous browsing is enabled and expect page not found" do
 217     Rails.configuration.Users.AnonymousUserToken = api_fixture('api_client_authorizations')['anonymous']['api_token']
 218     get(:show, params: {id: api_fixture('groups')['aproject']['uuid']})
 219     assert_response 404
 220     assert_match(/log ?in/i, @response.body)
 221   end
 222
 223   test "visit home page as anonymous when anonymous browsing is enabled and expect login" do
 224     Rails.configuration.Users.AnonymousUserToken = api_fixture('api_client_authorizations')['anonymous']['api_token']
 225     get(:index)
 226     assert_response :redirect
 227     assert_match /\/users\/welcome/, @response.redirect_url
 228   end
 229
 230   [
 231     nil,
 232     :active,
 233   ].each do |user|
 234     test "visit public projects page when anon config is enabled, as user #{user}, and expect page" do
 235       Rails.configuration.Users.AnonymousUserToken = api_fixture('api_client_authorizations')['anonymous']['api_token']
 236
 237       if user
 238         get :public, params: {}, session: session_for(user)
 239       else
 240         get :public
 241       end
 242
 243       assert_response :success
 244       assert_not_nil assigns(:objects)
 245       project_names = assigns(:objects).collect(&:name)
 246       assert_includes project_names, 'Unrestricted public data'
 247       assert_not_includes project_names, 'A Project'
 248       refute_empty css_select('[href="/projects/public"]')
 249     end
 250   end
 251
 252   test "visit public projects page when anon config is not enabled as active user and expect 404" do
 253     Rails.configuration.Users.AnonymousUserToken = ""
 254     Rails.configuration.Workbench.EnablePublicProjectsPage = false
 255     get :public, params: {}, session: session_for(:active)
 256     assert_response 404
 257   end
 258
 259   test "visit public projects page when anon config is enabled but public projects page is disabled as active user and expect 404" do
 260     Rails.configuration.Users.AnonymousUserToken = api_fixture('api_client_authorizations')['anonymous']['api_token']
 261     Rails.configuration.Workbench.EnablePublicProjectsPage = false
 262     get :public, params: {}, session: session_for(:active)
 263     assert_response 404
 264   end
 265
 266   test "visit public projects page when anon config is not enabled as anonymous and expect login page" do
 267     Rails.configuration.Users.AnonymousUserToken = ""
 268     Rails.configuration.Workbench.EnablePublicProjectsPage = false
 269     get :public
 270     assert_response :redirect
 271     assert_match /\/users\/welcome/, @response.redirect_url
 272     assert_empty css_select('[href="/projects/public"]')
 273   end
 274
 275   test "visit public projects page when anon config is enabled and public projects page is disabled and expect login page" do
 276     Rails.configuration.Users.AnonymousUserToken = api_fixture('api_client_authorizations')['anonymous']['api_token']
 277     Rails.configuration.Workbench.EnablePublicProjectsPage = false
 278     get :index
 279     assert_response :redirect
 280     assert_match /\/users\/welcome/, @response.redirect_url
 281     assert_empty css_select('[href="/projects/public"]')
 282   end
 283
 284   test "visit public projects page when anon config is not enabled and public projects page is enabled and expect login page" do
 285     Rails.configuration.Workbench.EnablePublicProjectsPage = true
 286     get :index
 287     assert_response :redirect
 288     assert_match /\/users\/welcome/, @response.redirect_url
 289     assert_empty css_select('[href="/projects/public"]')
 290   end
 291
 292   test "find a project and edit its description" do
 293     project = api_fixture('groups')['aproject']
 294     use_token :active
 295     found = Group.find(project['uuid'])
 296     found.description = 'test description update'
 297     found.save!
 298     get(:show, params: {id: project['uuid']}, session: session_for(:active))
 299     assert_includes @response.body, 'test description update'
 300   end
 301
 302   test "find a project and edit description to textile description" do
 303     project = api_fixture('groups')['aproject']
 304     use_token :active
 305     found = Group.find(project['uuid'])
 306     found.description = '*test bold description for textile formatting*'
 307     found.save!
 308     get(:show, params: {id: project['uuid']}, session: session_for(:active))
 309     assert_includes @response.body, '<strong>test bold description for textile formatting</strong>'
 310   end
 311
 312   test "find a project and edit description to html description" do
 313     project = api_fixture('groups')['aproject']
 314     use_token :active
 315     found = Group.find(project['uuid'])
 316     found.description = '<b>Textile</b> description with link to home page <a href="/">take me home</a>.'
 317     found.save!
 318     get(:show, params: {id: project['uuid']}, session: session_for(:active))
 319     assert_includes @response.body, '<b>Textile</b> description with link to home page <a href="/">take me home</a>.'
 320   end
 321
 322   test "find a project and edit description to unsafe html description" do
 323     project = api_fixture('groups')['aproject']
 324     use_token :active
 325     found = Group.find(project['uuid'])
 326     found.description = 'Textile description with unsafe script tag <script language="javascript">alert("Hello there")</script>.'
 327     found.save!
 328     get(:show, params: {id: project['uuid']}, session: session_for(:active))
 329     assert_includes @response.body, 'Textile description with unsafe script tag alert("Hello there").'
 330   end
 331
 332   # Tests #14519
 333   test "textile table on description renders as table html markup" do
 334     use_token :active
 335     project = api_fixture('groups')['aproject']
 336     textile_table = <<EOT
 337 table(table table-striped table-condensed).
 338 |_. First Header |_. Second Header |
 339 |Content Cell |Content Cell |
 340 |Content Cell |Content Cell |
 341 EOT
 342     found = Group.find(project['uuid'])
 343     found.description = textile_table
 344     found.save!
 345     get(:show, params: {id: project['uuid']}, session: session_for(:active))
 346     assert_includes @response.body, '<th>First Header'
 347     assert_includes @response.body, '<td>Content Cell'
 348   end
 349
 350   test "find a project and edit description to textile description with link to object" do
 351     project = api_fixture('groups')['aproject']
 352     use_token :active
 353     found = Group.find(project['uuid'])
 354
 355     # uses 'Link to object' as a hyperlink for the object
 356     found.description = '"Link to object":' + api_fixture('groups')['asubproject']['uuid']
 357     found.save!
 358     get(:show, params: {id: project['uuid']}, session: session_for(:active))
 359
 360     # check that input was converted to textile, not staying as inputted
 361     refute_includes  @response.body,'"Link to object"'
 362     refute_empty css_select('[href="/groups/zzzzz-j7d0g-axqo7eu9pwvna1x"]')
 363   end
 364
 365   test "project viewer can't see project sharing tab" do
 366     project = api_fixture('groups')['aproject']
 367     get(:show, params: {id: project['uuid']}, session: session_for(:project_viewer))
 368     refute_includes @response.body, '<div id="Sharing"'
 369     assert_includes @response.body, '<div id="Data_collections"'
 370   end
 371
 372   [
 373     'admin',
 374     'active',
 375   ].each do |username|
 376     test "#{username} can see project sharing tab" do
 377      project = api_fixture('groups')['aproject']
 378      get(:show, params: {id: project['uuid']}, session: session_for(username))
 379      assert_includes @response.body, '<div id="Sharing"'
 380      assert_includes @response.body, '<div id="Data_collections"'
 381     end
 382   end
 383
 384   [
 385     ['admin',true],
 386     ['active',true],
 387     ['project_viewer',false],
 388   ].each do |user, can_move|
 389     test "#{user} can move subproject from project #{can_move}" do
 390       get(:show, params: {id: api_fixture('groups')['aproject']['uuid']}, session: session_for(user))
 391       if can_move
 392         assert_includes @response.body, 'Move project...'
 393       else
 394         refute_includes @response.body, 'Move project...'
 395       end
 396     end
 397   end
 398
 399   [:admin, :active].each do |user|
 400     test "in dashboard other index page links as #{user}" do
 401       get :index, params: {}, session: session_for(user)
 402
 403       [["processes", "/all_processes"],
 404        ["collections", "/collections"],
 405       ].each do |target, path|
 406         assert_includes @response.body, "href=\"#{path}\""
 407         assert_includes @response.body, "All #{target}"
 408       end
 409     end
 410   end
 411
 412   test "dashboard should show the correct status for processes" do
 413     get :index, params: {}, session: session_for(:active)
 414     assert_select 'div.panel-body.recent-processes' do
 415       [
 416         {
 417           fixture: 'container_requests',
 418           state: 'completed',
 419           selectors: [['div.progress', false],
 420                       ['span.label.label-success', true, 'Complete']]
 421         },
 422         {
 423           fixture: 'container_requests',
 424           state: 'uncommitted',
 425           selectors: [['div.progress', false],
 426                       ['span.label.label-default', true, 'Uncommitted']]
 427         },
 428         {
 429           fixture: 'container_requests',
 430           state: 'queued',
 431           selectors: [['div.progress', false],
 432                       ['span.label.label-default', true, 'Queued']]
 433         },
 434         {
 435           fixture: 'container_requests',
 436           state: 'running',
 437           selectors: [['.label-info', true, 'Running']]
 438         },
 439         {
 440           fixture: 'pipeline_instances',
 441           state: 'new_pipeline',
 442           selectors: [['div.progress', false],
 443                       ['span.label.label-default', true, 'Not started']]
 444         },
 445         {
 446           fixture: 'pipeline_instances',
 447           state: 'pipeline_in_running_state',
 448           selectors: [['.label-info', true, 'Running']]
 449         },
 450       ].each do |c|
 451         uuid = api_fixture(c[:fixture])[c[:state]]['uuid']
 452         assert_select "div.dashboard-panel-info-row.row-#{uuid}" do
 453           if c.include? :selectors
 454             c[:selectors].each do |selector, should_show, label|
 455               assert_select selector, should_show, "UUID #{uuid} should #{should_show ? '' : 'not'} show '#{selector}'"
 456               if should_show and not label.nil?
 457                 assert_select selector, label, "UUID #{uuid} state label should show #{label}"
 458               end
 459             end
 460           end
 461         end
 462       end
 463     end
 464   end
 465
 466   test "visit a public project and verify the public projects page link exists" do
 467     Rails.configuration.Users.AnonymousUserToken = api_fixture('api_client_authorizations')['anonymous']['api_token']
 468     uuid = api_fixture('groups')['anonymously_accessible_project']['uuid']
 469     get :show, params: {id: uuid}
 470     project = assigns(:object)
 471     assert_equal uuid, project['uuid']
 472     refute_empty css_select("[href=\"/projects/#{project['uuid']}\"]")
 473     assert_includes @response.body, "<a href=\"/projects/public\">Public Projects</a>"
 474   end
 475
 476   test 'all_projects unaffected by params after use by ProjectsController (#6640)' do
 477     @controller = ProjectsController.new
 478     project_uuid = api_fixture('groups')['aproject']['uuid']
 479     get :index, params: {
 480       filters: [['uuid', '<', project_uuid]].to_json,
 481       limit: 0,
 482       offset: 1000,
 483     }, session: session_for(:active)
 484     assert_select "#projects-menu + ul li.divider ~ li a[href=\"/projects/#{project_uuid}\"]"
 485   end
 486
 487   [
 488     ["active", 5, ["aproject", "asubproject"], "anonymously_accessible_project"],
 489     ["user1_with_load", 2, ["project_with_10_collections"], "project_with_2_pipelines_and_60_crs"],
 490     ["admin", 5, ["anonymously_accessible_project", "subproject_in_anonymous_accessible_project"], "aproject"],
 491   ].each do |user, page_size, tree_segment, unexpected|
 492     # Note: this test is sensitive to database collation. It passes
 493     # with en_US.UTF-8.
 494     test "build my projects tree for #{user} user and verify #{unexpected} is omitted" do
 495       use_token user
 496
 497       tree, _, _ = @controller.send(:my_wanted_projects_tree,
 498                                     User.current,
 499                                     page_size)
 500
 501       tree_segment_at_depth_1 = api_fixture('groups')[tree_segment[0]]
 502       tree_segment_at_depth_2 = api_fixture('groups')[tree_segment[1]] if tree_segment[1]
 503
 504       node_depth = {}
 505       tree.each do |x|
 506         node_depth[x[:object]['uuid']] = x[:depth]
 507       end
 508
 509       assert_equal(1, node_depth[tree_segment_at_depth_1['uuid']])
 510       assert_equal(2, node_depth[tree_segment_at_depth_2['uuid']]) if tree_segment[1]
 511
 512       unexpected_project = api_fixture('groups')[unexpected]
 513       assert_nil(node_depth[unexpected_project['uuid']], node_depth.inspect)
 514     end
 515   end
 516
 517   [
 518     ["active", 1],
 519     ["project_viewer", 1],
 520     ["admin", 0],
 521   ].each do |user, size|
 522     test "starred projects for #{user}" do
 523       use_token user
 524       ctrl = ProjectsController.new
 525       current_user = User.find(api_fixture('users')[user]['uuid'])
 526       my_starred_project = ctrl.send :my_starred_projects, current_user
 527       assert_equal(size, my_starred_project.andand.size)
 528
 529       ctrl2 = ProjectsController.new
 530       current_user = User.find(api_fixture('users')[user]['uuid'])
 531       my_starred_project = ctrl2.send :my_starred_projects, current_user
 532       assert_equal(size, my_starred_project.andand.size)
 533     end
 534   end
 535
 536   test "unshare project and verify that it is no longer included in shared user's starred projects" do
 537     # remove sharing link
 538     use_token :system_user
 539     Link.find(api_fixture('links')['share_starred_project_with_project_viewer']['uuid']).destroy
 540
 541     # verify that project is no longer included in starred projects
 542     use_token :project_viewer
 543     current_user = User.find(api_fixture('users')['project_viewer']['uuid'])
 544     ctrl = ProjectsController.new
 545     my_starred_project = ctrl.send :my_starred_projects, current_user
 546     assert_equal(0, my_starred_project.andand.size)
 547
 548     # share it again
 549     @controller = LinksController.new
 550     post :create, params: {
 551       link: {
 552         link_class: 'permission',
 553         name: 'can_read',
 554         head_uuid: api_fixture('groups')['starred_and_shared_active_user_project']['uuid'],
 555         tail_uuid: api_fixture('users')['project_viewer']['uuid'],
 556       },
 557       format: :json
 558     }, session: session_for(:system_user)
 559
 560     # verify that the project is again included in starred projects
 561     use_token :project_viewer
 562     ctrl = ProjectsController.new
 563     my_starred_project = ctrl.send :my_starred_projects, current_user
 564     assert_equal(1, my_starred_project.andand.size)
 565   end
 566 end