test/controllers/traces_controller_test.rb

   1 require "test_helper"
   2
   3 class TracesControllerTest < ActionDispatch::IntegrationTest
   4   ##
   5   # test all routes which lead to this controller
   6   def test_routes
   7     assert_routing(
   8       { :path => "/traces", :method => :get },
   9       { :controller => "traces", :action => "index" }
  10     )
  11     assert_routing(
  12       { :path => "/traces/tag/tagname", :method => :get },
  13       { :controller => "traces", :action => "index", :tag => "tagname" }
  14     )
  15     assert_routing(
  16       { :path => "/user/username/traces", :method => :get },
  17       { :controller => "traces", :action => "index", :display_name => "username" }
  18     )
  19     assert_routing(
  20       { :path => "/user/username/traces/tag/tagname", :method => :get },
  21       { :controller => "traces", :action => "index", :display_name => "username", :tag => "tagname" }
  22     )
  23
  24     assert_routing(
  25       { :path => "/traces/mine", :method => :get },
  26       { :controller => "traces", :action => "mine" }
  27     )
  28     assert_routing(
  29       { :path => "/traces/mine/tag/tagname", :method => :get },
  30       { :controller => "traces", :action => "mine", :tag => "tagname" }
  31     )
  32
  33     assert_routing(
  34       { :path => "/user/username/traces/1", :method => :get },
  35       { :controller => "traces", :action => "show", :display_name => "username", :id => "1" }
  36     )
  37
  38     assert_routing(
  39       { :path => "/traces/new", :method => :get },
  40       { :controller => "traces", :action => "new" }
  41     )
  42     assert_routing(
  43       { :path => "/traces", :method => :post },
  44       { :controller => "traces", :action => "create" }
  45     )
  46     assert_routing(
  47       { :path => "/traces/1/edit", :method => :get },
  48       { :controller => "traces", :action => "edit", :id => "1" }
  49     )
  50     assert_routing(
  51       { :path => "/traces/1", :method => :put },
  52       { :controller => "traces", :action => "update", :id => "1" }
  53     )
  54     assert_routing(
  55       { :path => "/traces/1", :method => :delete },
  56       { :controller => "traces", :action => "destroy", :id => "1" }
  57     )
  58
  59     get "/traces/page/1"
  60     assert_redirected_to "/traces"
  61
  62     get "/traces/tag/tagname/page/1"
  63     assert_redirected_to "/traces/tag/tagname"
  64
  65     get "/user/username/traces/page/1"
  66     assert_redirected_to "/user/username/traces"
  67
  68     get "/user/username/traces/tag/tagname/page/1"
  69     assert_redirected_to "/user/username/traces/tag/tagname"
  70
  71     get "/traces/mine/page/1"
  72     assert_redirected_to "/traces/mine"
  73
  74     get "/traces/mine/tag/tagname/page/1"
  75     assert_redirected_to "/traces/mine/tag/tagname"
  76   end
  77
  78   # Check that the index of traces is displayed
  79   def test_index
  80     user = create(:user)
  81     # The fourth test below is surprisingly sensitive to timestamp ordering when the timestamps are equal.
  82     trace_a = create(:trace, :visibility => "public", :timestamp => 4.seconds.ago) do |trace|
  83       create(:tracetag, :trace => trace, :tag => "London")
  84     end
  85     trace_b = create(:trace, :visibility => "public", :timestamp => 3.seconds.ago) do |trace|
  86       create(:tracetag, :trace => trace, :tag => "Birmingham")
  87     end
  88     trace_c = create(:trace, :visibility => "private", :user => user, :timestamp => 2.seconds.ago) do |trace|
  89       create(:tracetag, :trace => trace, :tag => "London")
  90     end
  91     trace_d = create(:trace, :visibility => "private", :user => user, :timestamp => 1.second.ago) do |trace|
  92       create(:tracetag, :trace => trace, :tag => "Birmingham")
  93     end
  94
  95     # First with the public index
  96     get traces_path
  97     check_trace_index [trace_b, trace_a]
  98
  99     # Restrict traces to those with a given tag
 100     get traces_path(:tag => "London")
 101     check_trace_index [trace_a]
 102
 103     session_for(user)
 104
 105     # Should see more when we are logged in
 106     get traces_path
 107     check_trace_index [trace_d, trace_c, trace_b, trace_a]
 108
 109     # Again, we should see more when we are logged in
 110     get traces_path(:tag => "London")
 111     check_trace_index [trace_c, trace_a]
 112   end
 113
 114   # Check that I can get mine
 115   def test_index_mine
 116     user = create(:user)
 117     create(:trace, :visibility => "public") do |trace|
 118       create(:tracetag, :trace => trace, :tag => "Birmingham")
 119     end
 120     trace_b = create(:trace, :visibility => "private", :user => user) do |trace|
 121       create(:tracetag, :trace => trace, :tag => "London")
 122     end
 123
 124     # First try to get it when not logged in
 125     get traces_mine_path
 126     assert_redirected_to login_path(:referer => "/traces/mine")
 127
 128     session_for(user)
 129
 130     # Now try when logged in
 131     get traces_mine_path
 132     assert_redirected_to :action => "index", :display_name => user.display_name
 133
 134     # Fetch the actual index
 135     get traces_path(:display_name => user.display_name)
 136     check_trace_index [trace_b]
 137   end
 138
 139   # Check the index of traces for a specific user
 140   def test_index_user
 141     user = create(:user)
 142     checked_user_traces_path = url_for :only_path => true, :controller => "traces", :action => "index", :display_name => user.display_name
 143     second_user = create(:user)
 144     third_user = create(:user)
 145     create(:trace)
 146     trace_b = create(:trace, :visibility => "public", :user => user)
 147     trace_c = create(:trace, :visibility => "private", :user => user) do |trace|
 148       create(:tracetag, :trace => trace, :tag => "London")
 149     end
 150
 151     # Test a user with no traces
 152     get traces_path(:display_name => second_user.display_name)
 153     check_trace_index []
 154
 155     # Test the user with the traces - should see only public ones
 156     get traces_path(:display_name => user.display_name)
 157     check_trace_index [trace_b]
 158     assert_dom ".nav-tabs" do
 159       assert_dom "a[href='#{traces_path}']", :text => "All Traces", :count => 1
 160       assert_dom "a[href='#{traces_mine_path}']", :text => "My Traces", :count => 0
 161       assert_dom "a[href='#{checked_user_traces_path}']", :text => Regexp.new(Regexp.escape(user.display_name)), :count => 1
 162     end
 163
 164     session_for(third_user)
 165
 166     # Should still see only public ones when authenticated as another user
 167     get traces_path(:display_name => user.display_name)
 168     check_trace_index [trace_b]
 169     assert_dom ".nav-tabs" do
 170       assert_dom "a[href='#{traces_path}']", :text => "All Traces", :count => 1
 171       assert_dom "a[href='#{traces_mine_path}']", :text => "My Traces", :count => 1
 172       assert_dom "a[href='#{checked_user_traces_path}']", :text => Regexp.new(Regexp.escape(user.display_name)), :count => 1
 173     end
 174
 175     session_for(user)
 176
 177     # Should see all traces when authenticated as the target user
 178     get traces_path(:display_name => user.display_name)
 179     check_trace_index [trace_c, trace_b]
 180     assert_dom ".nav-tabs" do
 181       assert_dom "a[href='#{traces_path}']", :text => "All Traces", :count => 1
 182       assert_dom "a[href='#{traces_mine_path}']", :text => "My Traces", :count => 1
 183       assert_dom "a[href='#{checked_user_traces_path}']", :text => Regexp.new(Regexp.escape(user.display_name)), :count => 0
 184     end
 185
 186     # Should only see traces with the correct tag when a tag is specified
 187     get traces_path(:display_name => user.display_name, :tag => "London")
 188     check_trace_index [trace_c]
 189
 190     # Should get an error if the user does not exist
 191     get traces_path(:display_name => "UnknownUser")
 192     assert_response :not_found
 193     assert_template "users/no_such_user"
 194   end
 195
 196   # Check a multi-page index
 197   def test_index_paged
 198     # Create several pages worth of traces
 199     create_list(:trace, 50)
 200
 201     # Try and get the index
 202     get traces_path
 203     assert_response :success
 204     assert_select "table#trace_list tbody", :count => 1 do
 205       assert_select "tr", :count => 20
 206     end
 207     assert_select "li.page-item.disabled span.page-link", :text => "Newer Traces", :count => 2
 208     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 209
 210     # Try and get the second page
 211     get css_select("li.page-item a.page-link").last["href"]
 212     assert_response :success
 213     assert_select "table#trace_list tbody", :count => 1 do
 214       assert_select "tr", :count => 20
 215     end
 216     assert_select "li.page-item a.page-link", :text => "Newer Traces", :count => 2
 217     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 218
 219     # Try and get the third page
 220     get css_select("li.page-item a.page-link").last["href"]
 221     assert_response :success
 222     assert_select "table#trace_list tbody", :count => 1 do
 223       assert_select "tr", :count => 10
 224     end
 225     assert_select "li.page-item a.page-link", :text => "Newer Traces", :count => 2
 226     assert_select "li.page-item.disabled span.page-link", :text => "Older Traces", :count => 2
 227
 228     # Go back to the second page
 229     get css_select("li.page-item a.page-link").first["href"]
 230     assert_response :success
 231     assert_select "table#trace_list tbody", :count => 1 do
 232       assert_select "tr", :count => 20
 233     end
 234     assert_select "li.page-item a.page-link", :text => "Newer Traces", :count => 2
 235     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 236
 237     # Go back to the first page
 238     get css_select("li.page-item a.page-link").first["href"]
 239     assert_response :success
 240     assert_select "table#trace_list tbody", :count => 1 do
 241       assert_select "tr", :count => 20
 242     end
 243     assert_select "li.page-item.disabled span.page-link", :text => "Newer Traces", :count => 2
 244     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 245   end
 246
 247   # Check a multi-page index of tagged traces
 248   def test_index_tagged_paged
 249     # Create several pages worth of traces
 250     create_list(:trace, 100) do |trace, index|
 251       create(:tracetag, :trace => trace, :tag => "London") if index.even?
 252     end
 253
 254     # Try and get the index
 255     get traces_path(:tag => "London")
 256     assert_response :success
 257     assert_select "table#trace_list tbody", :count => 1 do
 258       assert_select "tr", :count => 20
 259     end
 260     assert_select "li.page-item.disabled span.page-link", :text => "Newer Traces", :count => 2
 261     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 262
 263     # Try and get the second page
 264     get css_select("li.page-item a.page-link").last["href"]
 265     assert_response :success
 266     assert_select "table#trace_list tbody", :count => 1 do
 267       assert_select "tr", :count => 20
 268     end
 269     assert_select "li.page-item a.page-link", :text => "Newer Traces", :count => 2
 270     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 271
 272     # Try and get the third page
 273     get css_select("li.page-item a.page-link").last["href"]
 274     assert_response :success
 275     assert_select "table#trace_list tbody", :count => 1 do
 276       assert_select "tr", :count => 10
 277     end
 278     assert_select "li.page-item a.page-link", :text => "Newer Traces", :count => 2
 279     assert_select "li.page-item.disabled span.page-link", :text => "Older Traces", :count => 2
 280
 281     # Go back to the second page
 282     get css_select("li.page-item a.page-link").first["href"]
 283     assert_response :success
 284     assert_select "table#trace_list tbody", :count => 1 do
 285       assert_select "tr", :count => 20
 286     end
 287     assert_select "li.page-item a.page-link", :text => "Newer Traces", :count => 2
 288     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 289
 290     # Go back to the first page
 291     get css_select("li.page-item a.page-link").first["href"]
 292     assert_response :success
 293     assert_select "table#trace_list tbody", :count => 1 do
 294       assert_select "tr", :count => 20
 295     end
 296     assert_select "li.page-item.disabled span.page-link", :text => "Newer Traces", :count => 2
 297     assert_select "li.page-item a.page-link", :text => "Older Traces", :count => 2
 298   end
 299
 300   def test_index_invalid_paged
 301     # Try some invalid paged accesses
 302     %w[-1 0 fred].each do |id|
 303       get traces_path(:before => id)
 304       assert_redirected_to :controller => :errors, :action => :bad_request
 305
 306       get traces_path(:after => id)
 307       assert_redirected_to :controller => :errors, :action => :bad_request
 308     end
 309   end
 310
 311   # Test showing a trace
 312   def test_show
 313     public_trace_file = create(:trace, :visibility => "public")
 314
 315     # First with no auth, which should work since the trace is public
 316     get show_trace_path(public_trace_file.user, public_trace_file)
 317     check_trace_show public_trace_file
 318
 319     # Now with some other user, which should work since the trace is public
 320     session_for(create(:user))
 321     get show_trace_path(public_trace_file.user, public_trace_file)
 322     check_trace_show public_trace_file
 323
 324     # And finally we should be able to do it with the owner of the trace
 325     session_for(public_trace_file.user)
 326     get show_trace_path(public_trace_file.user, public_trace_file)
 327     check_trace_show public_trace_file
 328   end
 329
 330   # Check an anonymous trace can't be viewed by another user
 331   def test_show_anon
 332     anon_trace_file = create(:trace, :visibility => "private")
 333
 334     # First with no auth
 335     get show_trace_path(anon_trace_file.user, anon_trace_file)
 336     assert_redirected_to :action => :index
 337
 338     # Now with some other user, which should not work since the trace is anon
 339     session_for(create(:user))
 340     get show_trace_path(anon_trace_file.user, anon_trace_file)
 341     assert_redirected_to :action => :index
 342
 343     # And finally we should be able to do it with the owner of the trace
 344     session_for(anon_trace_file.user)
 345     get show_trace_path(anon_trace_file.user, anon_trace_file)
 346     check_trace_show anon_trace_file
 347   end
 348
 349   # Test showing a trace that doesn't exist
 350   def test_show_not_found
 351     deleted_trace_file = create(:trace, :deleted)
 352
 353     # First with a trace that has never existed
 354     get show_trace_path(create(:user), 0)
 355     assert_redirected_to :action => :index
 356
 357     # Now with a trace that has been deleted
 358     session_for(deleted_trace_file.user)
 359     get show_trace_path(deleted_trace_file.user, deleted_trace_file)
 360     assert_redirected_to :action => :index
 361   end
 362
 363   # Test fetching the new trace page
 364   def test_new_get
 365     # First with no auth
 366     get new_trace_path
 367     assert_redirected_to login_path(:referer => new_trace_path)
 368
 369     # Now authenticated as a user with gps.trace.visibility set
 370     user = create(:user)
 371     create(:user_preference, :user => user, :k => "gps.trace.visibility", :v => "identifiable")
 372     session_for(user)
 373     get new_trace_path
 374     assert_response :success
 375     assert_template :new
 376     assert_select "select#trace_visibility option[value=identifiable][selected]", 1
 377
 378     # Now authenticated as a user with gps.trace.public set
 379     second_user = create(:user)
 380     create(:user_preference, :user => second_user, :k => "gps.trace.public", :v => "default")
 381     session_for(second_user)
 382     get new_trace_path
 383     assert_response :success
 384     assert_template :new
 385     assert_select "select#trace_visibility option[value=public][selected]", 1
 386
 387     # Now authenticated as a user with no preferences
 388     third_user = create(:user)
 389     session_for(third_user)
 390     get new_trace_path
 391     assert_response :success
 392     assert_template :new
 393     assert_select "select#trace_visibility option[value=private][selected]", 1
 394   end
 395
 396   # Test creating a trace
 397   def test_create_post
 398     # Get file to use
 399     fixture = Rails.root.join("test/gpx/fixtures/a.gpx")
 400     file = Rack::Test::UploadedFile.new(fixture, "application/gpx+xml")
 401     user = create(:user)
 402
 403     # First with no auth
 404     post traces_path(:trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" })
 405     assert_response :forbidden
 406
 407     # Rewind the file
 408     file.rewind
 409
 410     # Now authenticated
 411     create(:user_preference, :user => user, :k => "gps.trace.visibility", :v => "identifiable")
 412     assert_not_equal "trackable", user.preferences.find_by(:k => "gps.trace.visibility").v
 413     session_for(user)
 414     post traces_path, :params => { :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" } }
 415     assert_redirected_to :action => :index, :display_name => user.display_name
 416     assert_match(/file has been uploaded/, flash[:notice])
 417     trace = Trace.order(:id => :desc).first
 418     assert_equal "a.gpx", trace.name
 419     assert_equal "New Trace", trace.description
 420     assert_equal %w[new trace], trace.tags.order(:tag).collect(&:tag)
 421     assert_equal "trackable", trace.visibility
 422     assert_not trace.inserted
 423     assert_equal File.new(fixture).read, trace.file.blob.download
 424     trace.destroy
 425     assert_equal "trackable", user.preferences.find_by(:k => "gps.trace.visibility").v
 426   end
 427
 428   # Test creating a trace with validation errors
 429   def test_create_post_with_validation_errors
 430     # Get file to use
 431     fixture = Rails.root.join("test/gpx/fixtures/a.gpx")
 432     file = Rack::Test::UploadedFile.new(fixture, "application/gpx+xml")
 433     user = create(:user)
 434
 435     # Now authenticated
 436     create(:user_preference, :user => user, :k => "gps.trace.visibility", :v => "identifiable")
 437     assert_not_equal "trackable", user.preferences.find_by(:k => "gps.trace.visibility").v
 438     session_for(user)
 439     post traces_path, :params => { :trace => { :gpx_file => file, :description => "", :tagstring => "new,trace", :visibility => "trackable" } }
 440     assert_template :new
 441     assert_match "is too short (minimum is 1 character)", response.body
 442   end
 443
 444   # Test fetching the edit page for a trace using GET
 445   def test_edit_get
 446     public_trace_file = create(:trace, :visibility => "public")
 447     deleted_trace_file = create(:trace, :deleted)
 448
 449     # First with no auth
 450     get edit_trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file)
 451     assert_redirected_to login_path(:referer => edit_trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file.id))
 452
 453     # Now with some other user, which should fail
 454     session_for(create(:user))
 455     get edit_trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file)
 456     assert_response :forbidden
 457
 458     # Now with a trace which doesn't exist
 459     session_for(create(:user))
 460     get edit_trace_path(:display_name => create(:user).display_name, :id => 0)
 461     assert_response :not_found
 462
 463     # Now with a trace which has been deleted
 464     session_for(deleted_trace_file.user)
 465     get edit_trace_path(:display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file)
 466     assert_response :not_found
 467
 468     # Finally with a trace that we are allowed to edit
 469     session_for(public_trace_file.user)
 470     get edit_trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file)
 471     assert_response :success
 472   end
 473
 474   # Test saving edits to a trace
 475   def test_update
 476     public_trace_file = create(:trace, :visibility => "public")
 477     deleted_trace_file = create(:trace, :deleted)
 478
 479     # New details
 480     new_details = { :description => "Changed description", :tagstring => "new_tag", :visibility => "private" }
 481
 482     # First with no auth
 483     put trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file, :trace => new_details)
 484     assert_response :forbidden
 485
 486     # Now with some other user, which should fail
 487     session_for(create(:user))
 488     put trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file, :trace => new_details)
 489     assert_response :forbidden
 490
 491     # Now with a trace which doesn't exist
 492     session_for(create(:user))
 493     put trace_path(:display_name => create(:user).display_name, :id => 0, :trace => new_details)
 494     assert_response :not_found
 495
 496     # Now with a trace which has been deleted
 497     session_for(deleted_trace_file.user)
 498     put trace_path(:display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file, :trace => new_details)
 499     assert_response :not_found
 500
 501     # Finally with a trace that we are allowed to edit
 502     session_for(public_trace_file.user)
 503     put trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file, :trace => new_details)
 504     assert_redirected_to :action => :show, :display_name => public_trace_file.user.display_name
 505     trace = Trace.find(public_trace_file.id)
 506     assert_equal new_details[:description], trace.description
 507     assert_equal new_details[:tagstring], trace.tagstring
 508     assert_equal new_details[:visibility], trace.visibility
 509   end
 510
 511   # Test invalid updates
 512   def test_update_invalid
 513     trace = create(:trace)
 514
 515     # Invalid visibility
 516     session_for(trace.user)
 517     put trace_path(trace, :trace => { :description => "Changed description", :tagstring => "new_tag", :visibility => "wrong" })
 518     assert_response :success
 519     assert_select "title", :text => /^Editing Trace/
 520   end
 521
 522   # Test destroying a trace
 523   def test_destroy
 524     public_trace_file = create(:trace, :visibility => "public")
 525     deleted_trace_file = create(:trace, :deleted)
 526
 527     # First with no auth
 528     delete trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file)
 529     assert_response :forbidden
 530
 531     # Now with some other user, which should fail
 532     session_for(create(:user))
 533     delete trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file)
 534     assert_response :forbidden
 535
 536     # Now with a trace which doesn't exist
 537     session_for(create(:user))
 538     delete trace_path(:display_name => create(:user).display_name, :id => 0)
 539     assert_response :not_found
 540
 541     # Now with a trace has already been deleted
 542     session_for(deleted_trace_file.user)
 543     delete trace_path(:display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file)
 544     assert_response :not_found
 545
 546     # Now with a trace that we are allowed to delete
 547     session_for(public_trace_file.user)
 548     delete trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file)
 549     assert_redirected_to :action => :index, :display_name => public_trace_file.user.display_name
 550     trace = Trace.find(public_trace_file.id)
 551     assert_not trace.visible
 552
 553     # Finally with a trace that is destroyed by an admin
 554     public_trace_file = create(:trace, :visibility => "public")
 555     admin = create(:administrator_user)
 556     session_for(admin)
 557     delete trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file)
 558     assert_redirected_to :action => :index, :display_name => public_trace_file.user.display_name
 559     trace = Trace.find(public_trace_file.id)
 560     assert_not trace.visible
 561   end
 562
 563   private
 564
 565   def check_trace_index(traces)
 566     assert_response :success
 567     assert_template "index"
 568
 569     if traces.empty?
 570       assert_select "h2", /Nothing here yet/
 571     else
 572       assert_select "table#trace_list tbody", :count => 1 do
 573         assert_select "tr", :count => traces.length do |rows|
 574           traces.zip(rows).each do |trace, row|
 575             assert_select row, "a", Regexp.new(Regexp.escape(trace.name))
 576             assert_select row, "li", Regexp.new(Regexp.escape("#{trace.size} points")) if trace.inserted?
 577             assert_select row, "td", Regexp.new(Regexp.escape(trace.description))
 578             assert_select row, "td", Regexp.new(Regexp.escape("by #{trace.user.display_name}"))
 579             assert_select row, "a[href='#{user_path trace.user}']", :text => trace.user.display_name
 580           end
 581         end
 582       end
 583     end
 584   end
 585
 586   def check_trace_show(trace)
 587     assert_response :success
 588     assert_template "show"
 589
 590     assert_select "table", :count => 1 do
 591       assert_select "td", /^#{Regexp.quote(trace.name)} /
 592       assert_select "td a[href='#{user_path trace.user}']", :text => trace.user.display_name
 593       assert_select "td", trace.description
 594     end
 595   end
 596 end