test/controllers/changeset_controller_test.rb

   1 require "test_helper"
   2 require "changeset_controller"
   3
   4 class ChangesetControllerTest < ActionController::TestCase
   5   ##
   6   # test all routes which lead to this controller
   7   def test_routes
   8     assert_routing(
   9       { :path => "/api/0.6/changeset/create", :method => :put },
  10       { :controller => "changeset", :action => "create" }
  11     )
  12     assert_routing(
  13       { :path => "/api/0.6/changeset/1/upload", :method => :post },
  14       { :controller => "changeset", :action => "upload", :id => "1" }
  15     )
  16     assert_routing(
  17       { :path => "/api/0.6/changeset/1/download", :method => :get },
  18       { :controller => "changeset", :action => "download", :id => "1" }
  19     )
  20     assert_routing(
  21       { :path => "/api/0.6/changeset/1/expand_bbox", :method => :post },
  22       { :controller => "changeset", :action => "expand_bbox", :id => "1" }
  23     )
  24     assert_routing(
  25       { :path => "/api/0.6/changeset/1", :method => :get },
  26       { :controller => "changeset", :action => "read", :id => "1" }
  27     )
  28     assert_routing(
  29       { :path => "/api/0.6/changeset/1/subscribe", :method => :post },
  30       { :controller => "changeset", :action => "subscribe", :id => "1" }
  31     )
  32     assert_routing(
  33       { :path => "/api/0.6/changeset/1/unsubscribe", :method => :post },
  34       { :controller => "changeset", :action => "unsubscribe", :id => "1" }
  35     )
  36     assert_routing(
  37       { :path => "/api/0.6/changeset/1", :method => :put },
  38       { :controller => "changeset", :action => "update", :id => "1" }
  39     )
  40     assert_routing(
  41       { :path => "/api/0.6/changeset/1/close", :method => :put },
  42       { :controller => "changeset", :action => "close", :id => "1" }
  43     )
  44     assert_routing(
  45       { :path => "/api/0.6/changeset/1/comment", :method => :post },
  46       { :controller => "changeset", :action => "comment", :id => "1" }
  47     )
  48     assert_routing(
  49       { :path => "/api/0.6/changeset/comment/1/hide", :method => :post },
  50       { :controller => "changeset", :action => "hide_comment", :id => "1" }
  51     )
  52     assert_routing(
  53       { :path => "/api/0.6/changeset/comment/1/unhide", :method => :post },
  54       { :controller => "changeset", :action => "unhide_comment", :id => "1" }
  55     )
  56     assert_routing(
  57       { :path => "/api/0.6/changesets", :method => :get },
  58       { :controller => "changeset", :action => "query" }
  59     )
  60     assert_routing(
  61       { :path => "/changeset/1/comments/feed", :method => :get },
  62       { :controller => "changeset", :action => "comments_feed", :id => "1", :format => "rss" }
  63     )
  64     assert_routing(
  65       { :path => "/user/name/history", :method => :get },
  66       { :controller => "changeset", :action => "index", :display_name => "name" }
  67     )
  68     assert_routing(
  69       { :path => "/user/name/history/feed", :method => :get },
  70       { :controller => "changeset", :action => "feed", :display_name => "name", :format => :atom }
  71     )
  72     assert_routing(
  73       { :path => "/history/friends", :method => :get },
  74       { :controller => "changeset", :action => "index", :friends => true, :format => :html }
  75     )
  76     assert_routing(
  77       { :path => "/history/nearby", :method => :get },
  78       { :controller => "changeset", :action => "index", :nearby => true, :format => :html }
  79     )
  80     assert_routing(
  81       { :path => "/history", :method => :get },
  82       { :controller => "changeset", :action => "index" }
  83     )
  84     assert_routing(
  85       { :path => "/history/feed", :method => :get },
  86       { :controller => "changeset", :action => "feed", :format => :atom }
  87     )
  88     assert_routing(
  89       { :path => "/history/comments/feed", :method => :get },
  90       { :controller => "changeset", :action => "comments_feed", :format => "rss" }
  91     )
  92   end
  93
  94   # -----------------------
  95   # Test simple changeset creation
  96   # -----------------------
  97
  98   def test_create
  99     basic_authorization create(:user, :data_public => false).email, "test"
 100     # Create the first user's changeset
 101     content "<osm><changeset>" \
 102             "<tag k='created_by' v='osm test suite checking changesets'/>" \
 103             "</changeset></osm>"
 104     put :create
 105     assert_require_public_data
 106
 107     basic_authorization create(:user).email, "test"
 108     # Create the first user's changeset
 109     content "<osm><changeset>" \
 110             "<tag k='created_by' v='osm test suite checking changesets'/>" \
 111             "</changeset></osm>"
 112     put :create
 113
 114     assert_response :success, "Creation of changeset did not return sucess status"
 115     newid = @response.body.to_i
 116
 117     # check end time, should be an hour ahead of creation time
 118     cs = Changeset.find(newid)
 119     duration = cs.closed_at - cs.created_at
 120     # the difference can either be a rational, or a floating point number
 121     # of seconds, depending on the code path taken :-(
 122     if duration.class == Rational
 123       assert_equal Rational(1, 24), duration, "initial idle timeout should be an hour (#{cs.created_at} -> #{cs.closed_at})"
 124     else
 125       # must be number of seconds...
 126       assert_equal 3600, duration.round, "initial idle timeout should be an hour (#{cs.created_at} -> #{cs.closed_at})"
 127     end
 128
 129     # checks if uploader was subscribed
 130     assert_equal 1, cs.subscribers.length
 131   end
 132
 133   def test_create_invalid
 134     basic_authorization create(:user, :data_public => false).email, "test"
 135     content "<osm><changeset></osm>"
 136     put :create
 137     assert_require_public_data
 138
 139     ## Try the public user
 140     basic_authorization create(:user).email, "test"
 141     content "<osm><changeset></osm>"
 142     put :create
 143     assert_response :bad_request, "creating a invalid changeset should fail"
 144   end
 145
 146   def test_create_invalid_no_content
 147     ## First check with no auth
 148     put :create
 149     assert_response :unauthorized, "shouldn't be able to create a changeset with no auth"
 150
 151     ## Now try to with a non-public user
 152     basic_authorization create(:user, :data_public => false).email, "test"
 153     put :create
 154     assert_require_public_data
 155
 156     ## Try an inactive user
 157     basic_authorization create(:user, :pending).email, "test"
 158     put :create
 159     assert_inactive_user
 160
 161     ## Now try to use a normal user
 162     basic_authorization create(:user).email, "test"
 163     put :create
 164     assert_response :bad_request, "creating a changeset with no content should fail"
 165   end
 166
 167   def test_create_wrong_method
 168     basic_authorization create(:user).email, "test"
 169     get :create
 170     assert_response :method_not_allowed
 171     post :create
 172     assert_response :method_not_allowed
 173   end
 174
 175   ##
 176   # check that the changeset can be read and returns the correct
 177   # document structure.
 178   def test_read
 179     changeset_id = create(:changeset).id
 180
 181     get :read, :params => { :id => changeset_id }
 182     assert_response :success, "cannot get first changeset"
 183
 184     assert_select "osm[version='#{API_VERSION}'][generator='OpenStreetMap server']", 1
 185     assert_select "osm>changeset[id='#{changeset_id}']", 1
 186     assert_select "osm>changeset>discussion", 0
 187
 188     get :read, :params => { :id => changeset_id, :include_discussion => true }
 189     assert_response :success, "cannot get first changeset with comments"
 190
 191     assert_select "osm[version='#{API_VERSION}'][generator='OpenStreetMap server']", 1
 192     assert_select "osm>changeset[id='#{changeset_id}']", 1
 193     assert_select "osm>changeset>discussion", 1
 194     assert_select "osm>changeset>discussion>comment", 0
 195
 196     changeset_id = create(:changeset, :closed).id
 197     create_list(:changeset_comment, 3, :changeset_id => changeset_id)
 198
 199     get :read, :params => { :id => changeset_id, :include_discussion => true }
 200     assert_response :success, "cannot get closed changeset with comments"
 201
 202     assert_select "osm[version='#{API_VERSION}'][generator='OpenStreetMap server']", 1
 203     assert_select "osm>changeset[id='#{changeset_id}']", 1
 204     assert_select "osm>changeset>discussion", 1
 205     assert_select "osm>changeset>discussion>comment", 3
 206   end
 207
 208   ##
 209   # check that a changeset that doesn't exist returns an appropriate message
 210   def test_read_not_found
 211     [0, -32, 233455644, "afg", "213"].each do |id|
 212       begin
 213         get :read, :params => { :id => id }
 214         assert_response :not_found, "should get a not found"
 215       rescue ActionController::UrlGenerationError => ex
 216         assert_match(/No route matches/, ex.to_s)
 217       end
 218     end
 219   end
 220
 221   ##
 222   # test that the user who opened a change can close it
 223   def test_close
 224     private_user = create(:user, :data_public => false)
 225     private_changeset = create(:changeset, :user => private_user)
 226     user = create(:user)
 227     changeset = create(:changeset, :user => user)
 228
 229     ## Try without authentication
 230     put :close, :params => { :id => changeset.id }
 231     assert_response :unauthorized
 232
 233     ## Try using the non-public user
 234     basic_authorization private_user.email, "test"
 235     put :close, :params => { :id => private_changeset.id }
 236     assert_require_public_data
 237
 238     ## The try with the public user
 239     basic_authorization user.email, "test"
 240
 241     cs_id = changeset.id
 242     put :close, :params => { :id => cs_id }
 243     assert_response :success
 244
 245     # test that it really is closed now
 246     cs = Changeset.find(cs_id)
 247     assert_not(cs.is_open?,
 248                "changeset should be closed now (#{cs.closed_at} > #{Time.now.getutc}.")
 249   end
 250
 251   ##
 252   # test that a different user can't close another user's changeset
 253   def test_close_invalid
 254     user = create(:user)
 255     changeset = create(:changeset)
 256
 257     basic_authorization user.email, "test"
 258
 259     put :close, :params => { :id => changeset.id }
 260     assert_response :conflict
 261     assert_equal "The user doesn't own that changeset", @response.body
 262   end
 263
 264   ##
 265   # test that you can't close using another method
 266   def test_close_method_invalid
 267     user = create(:user)
 268     changeset = create(:changeset, :user => user)
 269
 270     basic_authorization user.email, "test"
 271
 272     get :close, :params => { :id => changeset.id }
 273     assert_response :method_not_allowed
 274
 275     post :close, :params => { :id => changeset.id }
 276     assert_response :method_not_allowed
 277   end
 278
 279   ##
 280   # check that you can't close a changeset that isn't found
 281   def test_close_not_found
 282     cs_ids = [0, -132, "123"]
 283
 284     # First try to do it with no auth
 285     cs_ids.each do |id|
 286       begin
 287         put :close, :params => { :id => id }
 288         assert_response :unauthorized, "Shouldn't be able close the non-existant changeset #{id}, when not authorized"
 289       rescue ActionController::UrlGenerationError => ex
 290         assert_match(/No route matches/, ex.to_s)
 291       end
 292     end
 293
 294     # Now try with auth
 295     basic_authorization create(:user).email, "test"
 296     cs_ids.each do |id|
 297       begin
 298         put :close, :params => { :id => id }
 299         assert_response :not_found, "The changeset #{id} doesn't exist, so can't be closed"
 300       rescue ActionController::UrlGenerationError => ex
 301         assert_match(/No route matches/, ex.to_s)
 302       end
 303     end
 304   end
 305
 306   ##
 307   # upload something simple, but valid and check that it can
 308   # be read back ok
 309   # Also try without auth and another user.
 310   def test_upload_simple_valid
 311     private_user = create(:user, :data_public => false)
 312     private_changeset = create(:changeset, :user => private_user)
 313     user = create(:user)
 314     changeset = create(:changeset, :user => user)
 315
 316     node = create(:node)
 317     way = create(:way)
 318     relation = create(:relation)
 319     other_relation = create(:relation)
 320     # create some tags, since we test that they are removed later
 321     create(:node_tag, :node => node)
 322     create(:way_tag, :way => way)
 323     create(:relation_tag, :relation => relation)
 324
 325     ## Try with no auth
 326     changeset_id = changeset.id
 327
 328     # simple diff to change a node, way and relation by removing
 329     # their tags
 330     diff = <<CHANGESET.strip_heredoc
 331       <osmChange>
 332        <modify>
 333         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
 334         <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
 335          <nd ref='#{node.id}'/>
 336         </way>
 337        </modify>
 338        <modify>
 339         <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
 340          <member type='way' role='some' ref='#{way.id}'/>
 341          <member type='node' role='some' ref='#{node.id}'/>
 342          <member type='relation' role='some' ref='#{other_relation.id}'/>
 343         </relation>
 344        </modify>
 345       </osmChange>
 346 CHANGESET
 347
 348     # upload it
 349     content diff
 350     post :upload, :params => { :id => changeset_id }
 351     assert_response :unauthorized,
 352                     "shouldn't be able to upload a simple valid diff to changeset: #{@response.body}"
 353
 354     ## Now try with a private user
 355     basic_authorization private_user.email, "test"
 356     changeset_id = private_changeset.id
 357
 358     # simple diff to change a node, way and relation by removing
 359     # their tags
 360     diff = <<CHANGESET.strip_heredoc
 361       <osmChange>
 362        <modify>
 363         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
 364         <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
 365          <nd ref='#{node.id}'/>
 366         </way>
 367        </modify>
 368        <modify>
 369         <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
 370          <member type='way' role='some' ref='#{way.id}'/>
 371          <member type='node' role='some' ref='#{node.id}'/>
 372          <member type='relation' role='some' ref='#{other_relation.id}'/>
 373         </relation>
 374        </modify>
 375       </osmChange>
 376 CHANGESET
 377
 378     # upload it
 379     content diff
 380     post :upload, :params => { :id => changeset_id }
 381     assert_response :forbidden,
 382                     "can't upload a simple valid diff to changeset: #{@response.body}"
 383
 384     ## Now try with the public user
 385     basic_authorization user.email, "test"
 386     changeset_id = changeset.id
 387
 388     # simple diff to change a node, way and relation by removing
 389     # their tags
 390     diff = <<CHANGESET.strip_heredoc
 391       <osmChange>
 392        <modify>
 393         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
 394         <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
 395          <nd ref='#{node.id}'/>
 396         </way>
 397        </modify>
 398        <modify>
 399         <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
 400          <member type='way' role='some' ref='#{way.id}'/>
 401          <member type='node' role='some' ref='#{node.id}'/>
 402          <member type='relation' role='some' ref='#{other_relation.id}'/>
 403         </relation>
 404        </modify>
 405       </osmChange>
 406 CHANGESET
 407
 408     # upload it
 409     content diff
 410     post :upload, :params => { :id => changeset_id }
 411     assert_response :success,
 412                     "can't upload a simple valid diff to changeset: #{@response.body}"
 413
 414     # check that the changes made it into the database
 415     assert_equal 0, Node.find(node.id).tags.size, "node #{node.id} should now have no tags"
 416     assert_equal 0, Way.find(way.id).tags.size, "way #{way.id} should now have no tags"
 417     assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
 418   end
 419
 420   ##
 421   # upload something which creates new objects using placeholders
 422   def test_upload_create_valid
 423     user = create(:user)
 424     changeset = create(:changeset, :user => user)
 425     node = create(:node)
 426     way = create(:way_with_nodes, :nodes_count => 2)
 427     relation = create(:relation)
 428
 429     basic_authorization user.email, "test"
 430
 431     # simple diff to create a node way and relation using placeholders
 432     diff = <<CHANGESET.strip_heredoc
 433       <osmChange>
 434        <create>
 435         <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 436          <tag k='foo' v='bar'/>
 437          <tag k='baz' v='bat'/>
 438         </node>
 439         <way id='-1' changeset='#{changeset.id}'>
 440          <nd ref='#{node.id}'/>
 441         </way>
 442        </create>
 443        <create>
 444         <relation id='-1' changeset='#{changeset.id}'>
 445          <member type='way' role='some' ref='#{way.id}'/>
 446          <member type='node' role='some' ref='#{node.id}'/>
 447          <member type='relation' role='some' ref='#{relation.id}'/>
 448         </relation>
 449        </create>
 450       </osmChange>
 451 CHANGESET
 452
 453     # upload it
 454     content diff
 455     post :upload, :params => { :id => changeset.id }
 456     assert_response :success,
 457                     "can't upload a simple valid creation to changeset: #{@response.body}"
 458
 459     # check the returned payload
 460     assert_select "diffResult[version='#{API_VERSION}'][generator='OpenStreetMap server']", 1
 461     assert_select "diffResult>node", 1
 462     assert_select "diffResult>way", 1
 463     assert_select "diffResult>relation", 1
 464
 465     # inspect the response to find out what the new element IDs are
 466     doc = XML::Parser.string(@response.body).parse
 467     new_node_id = doc.find("//diffResult/node").first["new_id"].to_i
 468     new_way_id = doc.find("//diffResult/way").first["new_id"].to_i
 469     new_rel_id = doc.find("//diffResult/relation").first["new_id"].to_i
 470
 471     # check the old IDs are all present and negative one
 472     assert_equal(-1, doc.find("//diffResult/node").first["old_id"].to_i)
 473     assert_equal(-1, doc.find("//diffResult/way").first["old_id"].to_i)
 474     assert_equal(-1, doc.find("//diffResult/relation").first["old_id"].to_i)
 475
 476     # check the versions are present and equal one
 477     assert_equal 1, doc.find("//diffResult/node").first["new_version"].to_i
 478     assert_equal 1, doc.find("//diffResult/way").first["new_version"].to_i
 479     assert_equal 1, doc.find("//diffResult/relation").first["new_version"].to_i
 480
 481     # check that the changes made it into the database
 482     assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
 483     assert_equal 0, Way.find(new_way_id).tags.size, "new way should have no tags"
 484     assert_equal 0, Relation.find(new_rel_id).tags.size, "new relation should have no tags"
 485   end
 486
 487   ##
 488   # test a complex delete where we delete elements which rely on eachother
 489   # in the same transaction.
 490   def test_upload_delete
 491     changeset = create(:changeset)
 492     super_relation = create(:relation)
 493     used_relation = create(:relation)
 494     used_way = create(:way)
 495     used_node = create(:node)
 496     create(:relation_member, :relation => super_relation, :member => used_relation)
 497     create(:relation_member, :relation => super_relation, :member => used_way)
 498     create(:relation_member, :relation => super_relation, :member => used_node)
 499
 500     basic_authorization changeset.user.display_name, "test"
 501
 502     diff = XML::Document.new
 503     diff.root = XML::Node.new "osmChange"
 504     delete = XML::Node.new "delete"
 505     diff.root << delete
 506     delete << super_relation.to_xml_node
 507     delete << used_relation.to_xml_node
 508     delete << used_way.to_xml_node
 509     delete << used_node.to_xml_node
 510
 511     # update the changeset to one that this user owns
 512     %w[node way relation].each do |type|
 513       delete.find("//osmChange/delete/#{type}").each do |n|
 514         n["changeset"] = changeset.id.to_s
 515       end
 516     end
 517
 518     # upload it
 519     content diff
 520     post :upload, :params => { :id => changeset.id }
 521     assert_response :success,
 522                     "can't upload a deletion diff to changeset: #{@response.body}"
 523
 524     # check the response is well-formed
 525     assert_select "diffResult>node", 1
 526     assert_select "diffResult>way", 1
 527     assert_select "diffResult>relation", 2
 528
 529     # check that everything was deleted
 530     assert_equal false, Node.find(used_node.id).visible
 531     assert_equal false, Way.find(used_way.id).visible
 532     assert_equal false, Relation.find(super_relation.id).visible
 533     assert_equal false, Relation.find(used_relation.id).visible
 534   end
 535
 536   ##
 537   # test uploading a delete with no lat/lon, as they are optional in
 538   # the osmChange spec.
 539   def test_upload_nolatlon_delete
 540     node = create(:node)
 541     changeset = create(:changeset)
 542
 543     basic_authorization changeset.user.display_name, "test"
 544     diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
 545
 546     # upload it
 547     content diff
 548     post :upload, :params => { :id => changeset.id }
 549     assert_response :success,
 550                     "can't upload a deletion diff to changeset: #{@response.body}"
 551
 552     # check the response is well-formed
 553     assert_select "diffResult>node", 1
 554
 555     # check that everything was deleted
 556     assert_equal false, Node.find(node.id).visible
 557   end
 558
 559   def test_repeated_changeset_create
 560     3.times do
 561       basic_authorization create(:user).email, "test"
 562
 563       # create a temporary changeset
 564       content "<osm><changeset>" \
 565               "<tag k='created_by' v='osm test suite checking changesets'/>" \
 566               "</changeset></osm>"
 567       assert_difference "Changeset.count", 1 do
 568         put :create
 569       end
 570       assert_response :success
 571     end
 572   end
 573
 574   def test_upload_large_changeset
 575     basic_authorization create(:user).email, "test"
 576
 577     # create a changeset
 578     content "<osm><changeset/></osm>"
 579     put :create
 580     assert_response :success, "Should be able to create a changeset: #{@response.body}"
 581     changeset_id = @response.body.to_i
 582
 583     # upload some widely-spaced nodes, spiralling positive and negative
 584     diff = <<CHANGESET.strip_heredoc
 585       <osmChange>
 586        <create>
 587         <node id='-1' lon='-20' lat='-10' changeset='#{changeset_id}'/>
 588         <node id='-10' lon='20'  lat='10' changeset='#{changeset_id}'/>
 589         <node id='-2' lon='-40' lat='-20' changeset='#{changeset_id}'/>
 590         <node id='-11' lon='40'  lat='20' changeset='#{changeset_id}'/>
 591         <node id='-3' lon='-60' lat='-30' changeset='#{changeset_id}'/>
 592         <node id='-12' lon='60'  lat='30' changeset='#{changeset_id}'/>
 593         <node id='-4' lon='-80' lat='-40' changeset='#{changeset_id}'/>
 594         <node id='-13' lon='80'  lat='40' changeset='#{changeset_id}'/>
 595         <node id='-5' lon='-100' lat='-50' changeset='#{changeset_id}'/>
 596         <node id='-14' lon='100'  lat='50' changeset='#{changeset_id}'/>
 597         <node id='-6' lon='-120' lat='-60' changeset='#{changeset_id}'/>
 598         <node id='-15' lon='120'  lat='60' changeset='#{changeset_id}'/>
 599         <node id='-7' lon='-140' lat='-70' changeset='#{changeset_id}'/>
 600         <node id='-16' lon='140'  lat='70' changeset='#{changeset_id}'/>
 601         <node id='-8' lon='-160' lat='-80' changeset='#{changeset_id}'/>
 602         <node id='-17' lon='160'  lat='80' changeset='#{changeset_id}'/>
 603         <node id='-9' lon='-179.9' lat='-89.9' changeset='#{changeset_id}'/>
 604         <node id='-18' lon='179.9'  lat='89.9' changeset='#{changeset_id}'/>
 605        </create>
 606       </osmChange>
 607 CHANGESET
 608
 609     # upload it, which used to cause an error like "PGError: ERROR:
 610     # integer out of range" (bug #2152). but shouldn't any more.
 611     content diff
 612     post :upload, :params => { :id => changeset_id }
 613     assert_response :success,
 614                     "can't upload a spatially-large diff to changeset: #{@response.body}"
 615
 616     # check that the changeset bbox is within bounds
 617     cs = Changeset.find(changeset_id)
 618     assert cs.min_lon >= -180 * GeoRecord::SCALE, "Minimum longitude (#{cs.min_lon / GeoRecord::SCALE}) should be >= -180 to be valid."
 619     assert cs.max_lon <= 180 * GeoRecord::SCALE, "Maximum longitude (#{cs.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
 620     assert cs.min_lat >= -90 * GeoRecord::SCALE, "Minimum latitude (#{cs.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
 621     assert cs.max_lat <= 90 * GeoRecord::SCALE, "Maximum latitude (#{cs.max_lat / GeoRecord::SCALE}) should be <= 90 to be valid."
 622   end
 623
 624   ##
 625   # test that deleting stuff in a transaction doesn't bypass the checks
 626   # to ensure that used elements are not deleted.
 627   def test_upload_delete_invalid
 628     changeset = create(:changeset)
 629     relation = create(:relation)
 630     other_relation = create(:relation)
 631     used_way = create(:way)
 632     used_node = create(:node)
 633     create(:relation_member, :relation => relation, :member => used_way)
 634     create(:relation_member, :relation => relation, :member => used_node)
 635
 636     basic_authorization changeset.user.email, "test"
 637
 638     diff = XML::Document.new
 639     diff.root = XML::Node.new "osmChange"
 640     delete = XML::Node.new "delete"
 641     diff.root << delete
 642     delete << other_relation.to_xml_node
 643     delete << used_way.to_xml_node
 644     delete << used_node.to_xml_node
 645
 646     # update the changeset to one that this user owns
 647     %w[node way relation].each do |type|
 648       delete.find("//osmChange/delete/#{type}").each do |n|
 649         n["changeset"] = changeset.id.to_s
 650       end
 651     end
 652
 653     # upload it
 654     content diff
 655     post :upload, :params => { :id => changeset.id }
 656     assert_response :precondition_failed,
 657                     "shouldn't be able to upload a invalid deletion diff: #{@response.body}"
 658     assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
 659
 660     # check that nothing was, in fact, deleted
 661     assert_equal true, Node.find(used_node.id).visible
 662     assert_equal true, Way.find(used_way.id).visible
 663     assert_equal true, Relation.find(relation.id).visible
 664     assert_equal true, Relation.find(other_relation.id).visible
 665   end
 666
 667   ##
 668   # test that a conditional delete of an in use object works.
 669   def test_upload_delete_if_unused
 670     changeset = create(:changeset)
 671     super_relation = create(:relation)
 672     used_relation = create(:relation)
 673     used_way = create(:way)
 674     used_node = create(:node)
 675     create(:relation_member, :relation => super_relation, :member => used_relation)
 676     create(:relation_member, :relation => super_relation, :member => used_way)
 677     create(:relation_member, :relation => super_relation, :member => used_node)
 678
 679     basic_authorization changeset.user.email, "test"
 680
 681     diff = XML::Document.new
 682     diff.root = XML::Node.new "osmChange"
 683     delete = XML::Node.new "delete"
 684     diff.root << delete
 685     delete["if-unused"] = ""
 686     delete << used_relation.to_xml_node
 687     delete << used_way.to_xml_node
 688     delete << used_node.to_xml_node
 689
 690     # update the changeset to one that this user owns
 691     %w[node way relation].each do |type|
 692       delete.find("//osmChange/delete/#{type}").each do |n|
 693         n["changeset"] = changeset.id.to_s
 694       end
 695     end
 696
 697     # upload it
 698     content diff
 699     post :upload, :params => { :id => changeset.id }
 700     assert_response :success,
 701                     "can't do a conditional delete of in use objects: #{@response.body}"
 702
 703     # check the returned payload
 704     assert_select "diffResult[version='#{API_VERSION}'][generator='OpenStreetMap server']", 1
 705     assert_select "diffResult>node", 1
 706     assert_select "diffResult>way", 1
 707     assert_select "diffResult>relation", 1
 708
 709     # parse the response
 710     doc = XML::Parser.string(@response.body).parse
 711
 712     # check the old IDs are all present and what we expect
 713     assert_equal used_node.id, doc.find("//diffResult/node").first["old_id"].to_i
 714     assert_equal used_way.id, doc.find("//diffResult/way").first["old_id"].to_i
 715     assert_equal used_relation.id, doc.find("//diffResult/relation").first["old_id"].to_i
 716
 717     # check the new IDs are all present and unchanged
 718     assert_equal used_node.id, doc.find("//diffResult/node").first["new_id"].to_i
 719     assert_equal used_way.id, doc.find("//diffResult/way").first["new_id"].to_i
 720     assert_equal used_relation.id, doc.find("//diffResult/relation").first["new_id"].to_i
 721
 722     # check the new versions are all present and unchanged
 723     assert_equal used_node.version, doc.find("//diffResult/node").first["new_version"].to_i
 724     assert_equal used_way.version, doc.find("//diffResult/way").first["new_version"].to_i
 725     assert_equal used_relation.version, doc.find("//diffResult/relation").first["new_version"].to_i
 726
 727     # check that nothing was, in fact, deleted
 728     assert_equal true, Node.find(used_node.id).visible
 729     assert_equal true, Way.find(used_way.id).visible
 730     assert_equal true, Relation.find(used_relation.id).visible
 731   end
 732
 733   ##
 734   # upload an element with a really long tag value
 735   def test_upload_invalid_too_long_tag
 736     changeset = create(:changeset)
 737
 738     basic_authorization changeset.user.email, "test"
 739
 740     # simple diff to create a node way and relation using placeholders
 741     diff = <<CHANGESET.strip_heredoc
 742       <osmChange>
 743        <create>
 744         <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 745          <tag k='foo' v='#{'x' * 256}'/>
 746         </node>
 747        </create>
 748       </osmChange>
 749 CHANGESET
 750
 751     # upload it
 752     content diff
 753     post :upload, :params => { :id => changeset.id }
 754     assert_response :bad_request,
 755                     "shoudln't be able to upload too long a tag to changeset: #{@response.body}"
 756   end
 757
 758   ##
 759   # upload something which creates new objects and inserts them into
 760   # existing containers using placeholders.
 761   def test_upload_complex
 762     way = create(:way)
 763     node = create(:node)
 764     relation = create(:relation)
 765     create(:way_node, :way => way, :node => node)
 766
 767     changeset = create(:changeset)
 768
 769     basic_authorization changeset.user.email, "test"
 770
 771     # simple diff to create a node way and relation using placeholders
 772     diff = <<CHANGESET.strip_heredoc
 773       <osmChange>
 774        <create>
 775         <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 776          <tag k='foo' v='bar'/>
 777          <tag k='baz' v='bat'/>
 778         </node>
 779        </create>
 780        <modify>
 781         <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 782          <nd ref='-1'/>
 783          <nd ref='#{node.id}'/>
 784         </way>
 785         <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 786          <member type='way' role='some' ref='#{way.id}'/>
 787          <member type='node' role='some' ref='-1'/>
 788          <member type='relation' role='some' ref='#{relation.id}'/>
 789         </relation>
 790        </modify>
 791       </osmChange>
 792 CHANGESET
 793
 794     # upload it
 795     content diff
 796     post :upload, :params => { :id => changeset.id }
 797     assert_response :success,
 798                     "can't upload a complex diff to changeset: #{@response.body}"
 799
 800     # check the returned payload
 801     assert_select "diffResult[version='#{API_VERSION}'][generator='#{GENERATOR}']", 1
 802     assert_select "diffResult>node", 1
 803     assert_select "diffResult>way", 1
 804     assert_select "diffResult>relation", 1
 805
 806     # inspect the response to find out what the new element IDs are
 807     doc = XML::Parser.string(@response.body).parse
 808     new_node_id = doc.find("//diffResult/node").first["new_id"].to_i
 809
 810     # check that the changes made it into the database
 811     assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
 812     assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
 813     Relation.find(relation.id).members.each do |type, id, _role|
 814       assert_equal new_node_id, id, "relation should contain new node" if type == "node"
 815     end
 816   end
 817
 818   ##
 819   # create a diff which references several changesets, which should cause
 820   # a rollback and none of the diff gets committed
 821   def test_upload_invalid_changesets
 822     changeset = create(:changeset)
 823     other_changeset = create(:changeset, :user => changeset.user)
 824     node = create(:node)
 825     way = create(:way)
 826     relation = create(:relation)
 827     other_relation = create(:relation)
 828
 829     basic_authorization changeset.user.email, "test"
 830
 831     # simple diff to create a node way and relation using placeholders
 832     diff = <<CHANGESET.strip_heredoc
 833       <osmChange>
 834        <modify>
 835         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
 836         <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 837          <nd ref='#{node.id}'/>
 838         </way>
 839        </modify>
 840        <modify>
 841         <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 842          <member type='way' role='some' ref='#{way.id}'/>
 843          <member type='node' role='some' ref='#{node.id}'/>
 844          <member type='relation' role='some' ref='#{other_relation.id}'/>
 845         </relation>
 846        </modify>
 847        <create>
 848         <node id='-1' lon='0' lat='0' changeset='#{other_changeset.id}'>
 849          <tag k='foo' v='bar'/>
 850          <tag k='baz' v='bat'/>
 851         </node>
 852        </create>
 853       </osmChange>
 854 CHANGESET
 855
 856     # upload it
 857     content diff
 858     post :upload, :params => { :id => changeset.id }
 859     assert_response :conflict,
 860                     "uploading a diff with multiple changesets should have failed"
 861
 862     # check that objects are unmodified
 863     assert_nodes_are_equal(node, Node.find(node.id))
 864     assert_ways_are_equal(way, Way.find(way.id))
 865     assert_relations_are_equal(relation, Relation.find(relation.id))
 866   end
 867
 868   ##
 869   # upload multiple versions of the same element in the same diff.
 870   def test_upload_multiple_valid
 871     node = create(:node)
 872     changeset = create(:changeset)
 873     basic_authorization changeset.user.email, "test"
 874
 875     # change the location of a node multiple times, each time referencing
 876     # the last version. doesn't this depend on version numbers being
 877     # sequential?
 878     diff = <<CHANGESET.strip_heredoc
 879       <osmChange>
 880        <modify>
 881         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
 882         <node id='#{node.id}' lon='1' lat='0' changeset='#{changeset.id}' version='2'/>
 883         <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='3'/>
 884         <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='4'/>
 885         <node id='#{node.id}' lon='2' lat='2' changeset='#{changeset.id}' version='5'/>
 886         <node id='#{node.id}' lon='3' lat='2' changeset='#{changeset.id}' version='6'/>
 887         <node id='#{node.id}' lon='3' lat='3' changeset='#{changeset.id}' version='7'/>
 888         <node id='#{node.id}' lon='9' lat='9' changeset='#{changeset.id}' version='8'/>
 889        </modify>
 890       </osmChange>
 891 CHANGESET
 892
 893     # upload it
 894     content diff
 895     post :upload, :params => { :id => changeset.id }
 896     assert_response :success,
 897                     "can't upload multiple versions of an element in a diff: #{@response.body}"
 898
 899     # check the response is well-formed. its counter-intuitive, but the
 900     # API will return multiple elements with the same ID and different
 901     # version numbers for each change we made.
 902     assert_select "diffResult>node", 8
 903   end
 904
 905   ##
 906   # upload multiple versions of the same element in the same diff, but
 907   # keep the version numbers the same.
 908   def test_upload_multiple_duplicate
 909     node = create(:node)
 910     changeset = create(:changeset)
 911
 912     basic_authorization changeset.user.email, "test"
 913
 914     diff = <<CHANGESET.strip_heredoc
 915       <osmChange>
 916        <modify>
 917         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
 918         <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 919        </modify>
 920       </osmChange>
 921 CHANGESET
 922
 923     # upload it
 924     content diff
 925     post :upload, :params => { :id => changeset.id }
 926     assert_response :conflict,
 927                     "shouldn't be able to upload the same element twice in a diff: #{@response.body}"
 928   end
 929
 930   ##
 931   # try to upload some elements without specifying the version
 932   def test_upload_missing_version
 933     changeset = create(:changeset)
 934
 935     basic_authorization changeset.user.email, "test"
 936
 937     diff = <<CHANGESET.strip_heredoc
 938       <osmChange>
 939        <modify>
 940        <node id='1' lon='1' lat='1' changeset='#{changeset.id}'/>
 941        </modify>
 942       </osmChange>
 943 CHANGESET
 944
 945     # upload it
 946     content diff
 947     post :upload, :params => { :id => changeset.id }
 948     assert_response :bad_request,
 949                     "shouldn't be able to upload an element without version: #{@response.body}"
 950   end
 951
 952   ##
 953   # try to upload with commands other than create, modify, or delete
 954   def test_action_upload_invalid
 955     changeset = create(:changeset)
 956
 957     basic_authorization changeset.user.email, "test"
 958
 959     diff = <<CHANGESET.strip_heredoc
 960       <osmChange>
 961         <ping>
 962          <node id='1' lon='1' lat='1' changeset='#{changeset.id}' />
 963         </ping>
 964       </osmChange>
 965 CHANGESET
 966     content diff
 967     post :upload, :params => { :id => changeset.id }
 968     assert_response :bad_request, "Shouldn't be able to upload a diff with the action ping"
 969     assert_equal @response.body, "Unknown action ping, choices are create, modify, delete"
 970   end
 971
 972   ##
 973   # upload a valid changeset which has a mixture of whitespace
 974   # to check a bug reported by ivansanchez (#1565).
 975   def test_upload_whitespace_valid
 976     changeset = create(:changeset)
 977     node = create(:node)
 978     way = create(:way_with_nodes, :nodes_count => 2)
 979     relation = create(:relation)
 980     other_relation = create(:relation)
 981     create(:relation_tag, :relation => relation)
 982
 983     basic_authorization changeset.user.email, "test"
 984
 985     diff = <<CHANGESET.strip_heredoc
 986       <osmChange>
 987        <modify><node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}'
 988         version='1'></node>
 989         <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='2'><tag k='k' v='v'/></node></modify>
 990        <modify>
 991        <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'><member
 992          type='way' role='some' ref='#{way.id}'/><member
 993           type='node' role='some' ref='#{node.id}'/>
 994          <member type='relation' role='some' ref='#{other_relation.id}'/>
 995         </relation>
 996        </modify></osmChange>
 997 CHANGESET
 998
 999     # upload it
1000     content diff
1001     post :upload, :params => { :id => changeset.id }
1002     assert_response :success,
1003                     "can't upload a valid diff with whitespace variations to changeset: #{@response.body}"
1004
1005     # check the response is well-formed
1006     assert_select "diffResult>node", 2
1007     assert_select "diffResult>relation", 1
1008
1009     # check that the changes made it into the database
1010     assert_equal 1, Node.find(node.id).tags.size, "node #{node.id} should now have one tag"
1011     assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
1012   end
1013
1014   ##
1015   # test that a placeholder can be reused within the same upload.
1016   def test_upload_reuse_placeholder_valid
1017     changeset = create(:changeset)
1018
1019     basic_authorization changeset.user.email, "test"
1020
1021     diff = <<CHANGESET.strip_heredoc
1022       <osmChange>
1023        <create>
1024         <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1025          <tag k="foo" v="bar"/>
1026         </node>
1027        </create>
1028        <modify>
1029         <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
1030        </modify>
1031        <delete>
1032         <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
1033        </delete>
1034       </osmChange>
1035 CHANGESET
1036
1037     # upload it
1038     content diff
1039     post :upload, :params => { :id => changeset.id }
1040     assert_response :success,
1041                     "can't upload a valid diff with re-used placeholders to changeset: #{@response.body}"
1042
1043     # check the response is well-formed
1044     assert_select "diffResult>node", 3
1045     assert_select "diffResult>node[old_id='-1']", 3
1046   end
1047
1048   ##
1049   # test what happens if a diff upload re-uses placeholder IDs in an
1050   # illegal way.
1051   def test_upload_placeholder_invalid
1052     changeset = create(:changeset)
1053
1054     basic_authorization changeset.user.email, "test"
1055
1056     diff = <<CHANGESET.strip_heredoc
1057       <osmChange>
1058        <create>
1059         <node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
1060         <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
1061         <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
1062        </create>
1063       </osmChange>
1064 CHANGESET
1065
1066     # upload it
1067     content diff
1068     post :upload, :params => { :id => changeset.id }
1069     assert_response :bad_request,
1070                     "shouldn't be able to re-use placeholder IDs"
1071   end
1072
1073   ##
1074   # test that uploading a way referencing invalid placeholders gives a
1075   # proper error, not a 500.
1076   def test_upload_placeholder_invalid_way
1077     changeset = create(:changeset)
1078     way = create(:way)
1079
1080     basic_authorization changeset.user.email, "test"
1081
1082     diff = <<CHANGESET.strip_heredoc
1083       <osmChange>
1084        <create>
1085         <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1086         <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1087         <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1088         <way id="-1" changeset="#{changeset.id}" version="1">
1089          <nd ref="-1"/>
1090          <nd ref="-2"/>
1091          <nd ref="-3"/>
1092          <nd ref="-4"/>
1093         </way>
1094        </create>
1095       </osmChange>
1096 CHANGESET
1097
1098     # upload it
1099     content diff
1100     post :upload, :params => { :id => changeset.id }
1101     assert_response :bad_request,
1102                     "shouldn't be able to use invalid placeholder IDs"
1103     assert_equal "Placeholder node not found for reference -4 in way -1", @response.body
1104
1105     # the same again, but this time use an existing way
1106     diff = <<CHANGESET.strip_heredoc
1107       <osmChange>
1108        <create>
1109         <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1110         <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1111         <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1112         <way id="#{way.id}" changeset="#{changeset.id}" version="1">
1113          <nd ref="-1"/>
1114          <nd ref="-2"/>
1115          <nd ref="-3"/>
1116          <nd ref="-4"/>
1117         </way>
1118        </create>
1119       </osmChange>
1120 CHANGESET
1121
1122     # upload it
1123     content diff
1124     post :upload, :params => { :id => changeset.id }
1125     assert_response :bad_request,
1126                     "shouldn't be able to use invalid placeholder IDs"
1127     assert_equal "Placeholder node not found for reference -4 in way #{way.id}", @response.body
1128   end
1129
1130   ##
1131   # test that uploading a relation referencing invalid placeholders gives a
1132   # proper error, not a 500.
1133   def test_upload_placeholder_invalid_relation
1134     changeset = create(:changeset)
1135     relation = create(:relation)
1136
1137     basic_authorization changeset.user.email, "test"
1138
1139     diff = <<CHANGESET.strip_heredoc
1140       <osmChange>
1141        <create>
1142         <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1143         <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1144         <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1145         <relation id="-1" changeset="#{changeset.id}" version="1">
1146          <member type="node" role="foo" ref="-1"/>
1147          <member type="node" role="foo" ref="-2"/>
1148          <member type="node" role="foo" ref="-3"/>
1149          <member type="node" role="foo" ref="-4"/>
1150         </relation>
1151        </create>
1152       </osmChange>
1153 CHANGESET
1154
1155     # upload it
1156     content diff
1157     post :upload, :params => { :id => changeset.id }
1158     assert_response :bad_request,
1159                     "shouldn't be able to use invalid placeholder IDs"
1160     assert_equal "Placeholder Node not found for reference -4 in relation -1.", @response.body
1161
1162     # the same again, but this time use an existing relation
1163     diff = <<CHANGESET.strip_heredoc
1164       <osmChange>
1165        <create>
1166         <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1167         <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1168         <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1169         <relation id="#{relation.id}" changeset="#{changeset.id}" version="1">
1170          <member type="node" role="foo" ref="-1"/>
1171          <member type="node" role="foo" ref="-2"/>
1172          <member type="node" role="foo" ref="-3"/>
1173          <member type="way" role="bar" ref="-1"/>
1174         </relation>
1175        </create>
1176       </osmChange>
1177 CHANGESET
1178
1179     # upload it
1180     content diff
1181     post :upload, :params => { :id => changeset.id }
1182     assert_response :bad_request,
1183                     "shouldn't be able to use invalid placeholder IDs"
1184     assert_equal "Placeholder Way not found for reference -1 in relation #{relation.id}.", @response.body
1185   end
1186
1187   ##
1188   # test what happens if a diff is uploaded containing only a node
1189   # move.
1190   def test_upload_node_move
1191     basic_authorization create(:user).email, "test"
1192
1193     content "<osm><changeset>" \
1194             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1195             "</changeset></osm>"
1196     put :create
1197     assert_response :success
1198     changeset_id = @response.body.to_i
1199
1200     old_node = create(:node, :lat => 1, :lon => 1)
1201
1202     diff = XML::Document.new
1203     diff.root = XML::Node.new "osmChange"
1204     modify = XML::Node.new "modify"
1205     xml_old_node = old_node.to_xml_node
1206     xml_old_node["lat"] = 2.0.to_s
1207     xml_old_node["lon"] = 2.0.to_s
1208     xml_old_node["changeset"] = changeset_id.to_s
1209     modify << xml_old_node
1210     diff.root << modify
1211
1212     # upload it
1213     content diff
1214     post :upload, :params => { :id => changeset_id }
1215     assert_response :success,
1216                     "diff should have uploaded OK"
1217
1218     # check the bbox
1219     changeset = Changeset.find(changeset_id)
1220     assert_equal 1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 1 degree"
1221     assert_equal 2 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2 degrees"
1222     assert_equal 1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1 degree"
1223     assert_equal 2 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 2 degrees"
1224   end
1225
1226   ##
1227   # test what happens if a diff is uploaded adding a node to a way.
1228   def test_upload_way_extend
1229     basic_authorization create(:user).email, "test"
1230
1231     content "<osm><changeset>" \
1232             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1233             "</changeset></osm>"
1234     put :create
1235     assert_response :success
1236     changeset_id = @response.body.to_i
1237
1238     old_way = create(:way)
1239     create(:way_node, :way => old_way, :node => create(:node, :lat => 1, :lon => 1))
1240
1241     diff = XML::Document.new
1242     diff.root = XML::Node.new "osmChange"
1243     modify = XML::Node.new "modify"
1244     xml_old_way = old_way.to_xml_node
1245     nd_ref = XML::Node.new "nd"
1246     nd_ref["ref"] = create(:node, :lat => 3, :lon => 3).id.to_s
1247     xml_old_way << nd_ref
1248     xml_old_way["changeset"] = changeset_id.to_s
1249     modify << xml_old_way
1250     diff.root << modify
1251
1252     # upload it
1253     content diff
1254     post :upload, :params => { :id => changeset_id }
1255     assert_response :success,
1256                     "diff should have uploaded OK"
1257
1258     # check the bbox
1259     changeset = Changeset.find(changeset_id)
1260     assert_equal 1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 1 degree"
1261     assert_equal 3 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 3 degrees"
1262     assert_equal 1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1 degree"
1263     assert_equal 3 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 3 degrees"
1264   end
1265
1266   ##
1267   # test for more issues in #1568
1268   def test_upload_empty_invalid
1269     changeset = create(:changeset)
1270
1271     basic_authorization changeset.user.email, "test"
1272
1273     ["<osmChange/>",
1274      "<osmChange></osmChange>",
1275      "<osmChange><modify/></osmChange>",
1276      "<osmChange><modify></modify></osmChange>"].each do |diff|
1277       # upload it
1278       content diff
1279       post :upload, :params => { :id => changeset.id }
1280       assert_response(:success, "should be able to upload " \
1281                       "empty changeset: " + diff)
1282     end
1283   end
1284
1285   ##
1286   # test that the X-Error-Format header works to request XML errors
1287   def test_upload_xml_errors
1288     changeset = create(:changeset)
1289     node = create(:node)
1290     create(:relation_member, :member => node)
1291
1292     basic_authorization changeset.user.email, "test"
1293
1294     # try and delete a node that is in use
1295     diff = XML::Document.new
1296     diff.root = XML::Node.new "osmChange"
1297     delete = XML::Node.new "delete"
1298     diff.root << delete
1299     delete << node.to_xml_node
1300
1301     # upload it
1302     content diff
1303     error_format "xml"
1304     post :upload, :params => { :id => changeset.id }
1305     assert_response :success,
1306                     "failed to return error in XML format"
1307
1308     # check the returned payload
1309     assert_select "osmError[version='#{API_VERSION}'][generator='OpenStreetMap server']", 1
1310     assert_select "osmError>status", 1
1311     assert_select "osmError>message", 1
1312   end
1313
1314   ##
1315   # when we make some simple changes we get the same changes back from the
1316   # diff download.
1317   def test_diff_download_simple
1318     node = create(:node)
1319
1320     ## First try with a non-public user, which should get a forbidden
1321     basic_authorization create(:user, :data_public => false).email, "test"
1322
1323     # create a temporary changeset
1324     content "<osm><changeset>" \
1325             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1326             "</changeset></osm>"
1327     put :create
1328     assert_response :forbidden
1329
1330     ## Now try with a normal user
1331     basic_authorization create(:user).email, "test"
1332
1333     # create a temporary changeset
1334     content "<osm><changeset>" \
1335             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1336             "</changeset></osm>"
1337     put :create
1338     assert_response :success
1339     changeset_id = @response.body.to_i
1340
1341     # add a diff to it
1342     diff = <<CHANGESET.strip_heredoc
1343       <osmChange>
1344        <modify>
1345         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
1346         <node id='#{node.id}' lon='1' lat='0' changeset='#{changeset_id}' version='2'/>
1347         <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset_id}' version='3'/>
1348         <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset_id}' version='4'/>
1349         <node id='#{node.id}' lon='2' lat='2' changeset='#{changeset_id}' version='5'/>
1350         <node id='#{node.id}' lon='3' lat='2' changeset='#{changeset_id}' version='6'/>
1351         <node id='#{node.id}' lon='3' lat='3' changeset='#{changeset_id}' version='7'/>
1352         <node id='#{node.id}' lon='9' lat='9' changeset='#{changeset_id}' version='8'/>
1353        </modify>
1354       </osmChange>
1355 CHANGESET
1356
1357     # upload it
1358     content diff
1359     post :upload, :params => { :id => changeset_id }
1360     assert_response :success,
1361                     "can't upload multiple versions of an element in a diff: #{@response.body}"
1362
1363     get :download, :params => { :id => changeset_id }
1364     assert_response :success
1365
1366     assert_select "osmChange", 1
1367     assert_select "osmChange>modify", 8
1368     assert_select "osmChange>modify>node", 8
1369   end
1370
1371   ##
1372   # culled this from josm to ensure that nothing in the way that josm
1373   # is formatting the request is causing it to fail.
1374   #
1375   # NOTE: the error turned out to be something else completely!
1376   def test_josm_upload
1377     basic_authorization create(:user).email, "test"
1378
1379     # create a temporary changeset
1380     content "<osm><changeset>" \
1381             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1382             "</changeset></osm>"
1383     put :create
1384     assert_response :success
1385     changeset_id = @response.body.to_i
1386
1387     diff = <<OSMFILE.strip_heredoc
1388       <osmChange version="0.6" generator="JOSM">
1389       <create version="0.6" generator="JOSM">
1390         <node id='-1' visible='true' changeset='#{changeset_id}' lat='51.49619982187321' lon='-0.18722061869438314' />
1391         <node id='-2' visible='true' changeset='#{changeset_id}' lat='51.496359883909605' lon='-0.18653093576241928' />
1392         <node id='-3' visible='true' changeset='#{changeset_id}' lat='51.49598132358285' lon='-0.18719613290981638' />
1393         <node id='-4' visible='true' changeset='#{changeset_id}' lat='51.4961591711078' lon='-0.18629015888084607' />
1394         <node id='-5' visible='true' changeset='#{changeset_id}' lat='51.49582126021711' lon='-0.18708186591517145' />
1395         <node id='-6' visible='true' changeset='#{changeset_id}' lat='51.49591018437858' lon='-0.1861432441734455' />
1396         <node id='-7' visible='true' changeset='#{changeset_id}' lat='51.49560784152179' lon='-0.18694719410005425' />
1397         <node id='-8' visible='true' changeset='#{changeset_id}' lat='51.49567389979617' lon='-0.1860289771788006' />
1398         <node id='-9' visible='true' changeset='#{changeset_id}' lat='51.49543761398892' lon='-0.186820684213126' />
1399         <way id='-10' action='modiy' visible='true' changeset='#{changeset_id}'>
1400           <nd ref='-1' />
1401           <nd ref='-2' />
1402           <nd ref='-3' />
1403           <nd ref='-4' />
1404           <nd ref='-5' />
1405           <nd ref='-6' />
1406           <nd ref='-7' />
1407           <nd ref='-8' />
1408           <nd ref='-9' />
1409           <tag k='highway' v='residential' />
1410           <tag k='name' v='Foobar Street' />
1411         </way>
1412       </create>
1413       </osmChange>
1414 OSMFILE
1415
1416     # upload it
1417     content diff
1418     post :upload, :params => { :id => changeset_id }
1419     assert_response :success,
1420                     "can't upload a diff from JOSM: #{@response.body}"
1421
1422     get :download, :params => { :id => changeset_id }
1423     assert_response :success
1424
1425     assert_select "osmChange", 1
1426     assert_select "osmChange>create>node", 9
1427     assert_select "osmChange>create>way", 1
1428     assert_select "osmChange>create>way>nd", 9
1429     assert_select "osmChange>create>way>tag", 2
1430   end
1431
1432   ##
1433   # when we make some complex changes we get the same changes back from the
1434   # diff download.
1435   def test_diff_download_complex
1436     node = create(:node)
1437     node2 = create(:node)
1438     way = create(:way)
1439     basic_authorization create(:user).email, "test"
1440
1441     # create a temporary changeset
1442     content "<osm><changeset>" \
1443             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1444             "</changeset></osm>"
1445     put :create
1446     assert_response :success
1447     changeset_id = @response.body.to_i
1448
1449     # add a diff to it
1450     diff = <<CHANGESET.strip_heredoc
1451       <osmChange>
1452        <delete>
1453         <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
1454        </delete>
1455        <create>
1456         <node id='-1' lon='9' lat='9' changeset='#{changeset_id}' version='0'/>
1457         <node id='-2' lon='8' lat='9' changeset='#{changeset_id}' version='0'/>
1458         <node id='-3' lon='7' lat='9' changeset='#{changeset_id}' version='0'/>
1459        </create>
1460        <modify>
1461         <node id='#{node2.id}' lon='20' lat='15' changeset='#{changeset_id}' version='1'/>
1462         <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
1463          <nd ref='#{node2.id}'/>
1464          <nd ref='-1'/>
1465          <nd ref='-2'/>
1466          <nd ref='-3'/>
1467         </way>
1468        </modify>
1469       </osmChange>
1470 CHANGESET
1471
1472     # upload it
1473     content diff
1474     post :upload, :params => { :id => changeset_id }
1475     assert_response :success,
1476                     "can't upload multiple versions of an element in a diff: #{@response.body}"
1477
1478     get :download, :params => { :id => changeset_id }
1479     assert_response :success
1480
1481     assert_select "osmChange", 1
1482     assert_select "osmChange>create", 3
1483     assert_select "osmChange>delete", 1
1484     assert_select "osmChange>modify", 2
1485     assert_select "osmChange>create>node", 3
1486     assert_select "osmChange>delete>node", 1
1487     assert_select "osmChange>modify>node", 1
1488     assert_select "osmChange>modify>way", 1
1489   end
1490
1491   def test_changeset_download
1492     changeset = create(:changeset)
1493     node = create(:node, :with_history, :version => 1, :changeset => changeset)
1494     tag = create(:old_node_tag, :old_node => node.old_nodes.find_by(:version => 1))
1495     node2 = create(:node, :with_history, :version => 1, :changeset => changeset)
1496     _node3 = create(:node, :with_history, :deleted, :version => 1, :changeset => changeset)
1497     _relation = create(:relation, :with_history, :version => 1, :changeset => changeset)
1498     _relation2 = create(:relation, :with_history, :deleted, :version => 1, :changeset => changeset)
1499
1500     get :download, :params => { :id => changeset.id }
1501
1502     assert_response :success
1503     assert_template nil
1504     # print @response.body
1505     # FIXME: needs more assert_select tests
1506     assert_select "osmChange[version='#{API_VERSION}'][generator='#{GENERATOR}']" do
1507       assert_select "create", :count => 5
1508       assert_select "create>node[id='#{node.id}'][visible='#{node.visible?}'][version='#{node.version}']" do
1509         assert_select "tag[k='#{tag.k}'][v='#{tag.v}']"
1510       end
1511       assert_select "create>node[id='#{node2.id}']"
1512     end
1513   end
1514
1515   ##
1516   # check that the bounding box of a changeset gets updated correctly
1517   # FIXME: This should really be moded to a integration test due to the with_controller
1518   def test_changeset_bbox
1519     way = create(:way)
1520     create(:way_node, :way => way, :node => create(:node, :lat => 3, :lon => 3))
1521
1522     basic_authorization create(:user).email, "test"
1523
1524     # create a new changeset
1525     content "<osm><changeset/></osm>"
1526     put :create
1527     assert_response :success, "Creating of changeset failed."
1528     changeset_id = @response.body.to_i
1529
1530     # add a single node to it
1531     with_controller(NodeController.new) do
1532       content "<osm><node lon='1' lat='2' changeset='#{changeset_id}'/></osm>"
1533       put :create
1534       assert_response :success, "Couldn't create node."
1535     end
1536
1537     # get the bounding box back from the changeset
1538     get :read, :params => { :id => changeset_id }
1539     assert_response :success, "Couldn't read back changeset."
1540     assert_select "osm>changeset[min_lon='1.0000000']", 1
1541     assert_select "osm>changeset[max_lon='1.0000000']", 1
1542     assert_select "osm>changeset[min_lat='2.0000000']", 1
1543     assert_select "osm>changeset[max_lat='2.0000000']", 1
1544
1545     # add another node to it
1546     with_controller(NodeController.new) do
1547       content "<osm><node lon='2' lat='1' changeset='#{changeset_id}'/></osm>"
1548       put :create
1549       assert_response :success, "Couldn't create second node."
1550     end
1551
1552     # get the bounding box back from the changeset
1553     get :read, :params => { :id => changeset_id }
1554     assert_response :success, "Couldn't read back changeset for the second time."
1555     assert_select "osm>changeset[min_lon='1.0000000']", 1
1556     assert_select "osm>changeset[max_lon='2.0000000']", 1
1557     assert_select "osm>changeset[min_lat='1.0000000']", 1
1558     assert_select "osm>changeset[max_lat='2.0000000']", 1
1559
1560     # add (delete) a way to it, which contains a point at (3,3)
1561     with_controller(WayController.new) do
1562       content update_changeset(way.to_xml, changeset_id)
1563       put :delete, :params => { :id => way.id }
1564       assert_response :success, "Couldn't delete a way."
1565     end
1566
1567     # get the bounding box back from the changeset
1568     get :read, :params => { :id => changeset_id }
1569     assert_response :success, "Couldn't read back changeset for the third time."
1570     assert_select "osm>changeset[min_lon='1.0000000']", 1
1571     assert_select "osm>changeset[max_lon='3.0000000']", 1
1572     assert_select "osm>changeset[min_lat='1.0000000']", 1
1573     assert_select "osm>changeset[max_lat='3.0000000']", 1
1574   end
1575
1576   ##
1577   # test that the changeset :include method works as it should
1578   def test_changeset_include
1579     basic_authorization create(:user).display_name, "test"
1580
1581     # create a new changeset
1582     content "<osm><changeset/></osm>"
1583     put :create
1584     assert_response :success, "Creating of changeset failed."
1585     changeset_id = @response.body.to_i
1586
1587     # NOTE: the include method doesn't over-expand, like inserting
1588     # a real method does. this is because we expect the client to
1589     # know what it is doing!
1590     check_after_include(changeset_id, 1, 1, [1, 1, 1, 1])
1591     check_after_include(changeset_id, 3, 3, [1, 1, 3, 3])
1592     check_after_include(changeset_id, 4, 2, [1, 1, 4, 3])
1593     check_after_include(changeset_id, 2, 2, [1, 1, 4, 3])
1594     check_after_include(changeset_id, -1, -1, [-1, -1, 4, 3])
1595     check_after_include(changeset_id, -2, 5, [-2, -1, 4, 5])
1596   end
1597
1598   ##
1599   # test that a not found, wrong method with the expand bbox works as expected
1600   def test_changeset_expand_bbox_error
1601     basic_authorization create(:user).display_name, "test"
1602
1603     # create a new changeset
1604     content "<osm><changeset/></osm>"
1605     put :create
1606     assert_response :success, "Creating of changeset failed."
1607     changeset_id = @response.body.to_i
1608
1609     lon = 58.2
1610     lat = -0.45
1611
1612     # Try and put
1613     content "<osm><node lon='#{lon}' lat='#{lat}'/></osm>"
1614     put :expand_bbox, :params => { :id => changeset_id }
1615     assert_response :method_not_allowed, "shouldn't be able to put a bbox expand"
1616
1617     # Try to get the update
1618     content "<osm><node lon='#{lon}' lat='#{lat}'/></osm>"
1619     get :expand_bbox, :params => { :id => changeset_id }
1620     assert_response :method_not_allowed, "shouldn't be able to get a bbox expand"
1621
1622     # Try to use a hopefully missing changeset
1623     content "<osm><node lon='#{lon}' lat='#{lat}'/></osm>"
1624     post :expand_bbox, :params => { :id => changeset_id + 13245 }
1625     assert_response :not_found, "shouldn't be able to do a bbox expand on a nonexistant changeset"
1626   end
1627
1628   ##
1629   # test the query functionality of changesets
1630   def test_query
1631     private_user = create(:user, :data_public => false)
1632     private_user_changeset = create(:changeset, :user => private_user)
1633     private_user_closed_changeset = create(:changeset, :closed, :user => private_user)
1634     user = create(:user)
1635     changeset = create(:changeset, :user => user)
1636     closed_changeset = create(:changeset, :closed, :user => user, :created_at => Time.utc(2008, 1, 1, 0, 0, 0), :closed_at => Time.utc(2008, 1, 2, 0, 0, 0))
1637     changeset2 = create(:changeset, :min_lat => 5 * GeoRecord::SCALE, :min_lon => 5 * GeoRecord::SCALE, :max_lat => 15 * GeoRecord::SCALE, :max_lon => 15 * GeoRecord::SCALE)
1638     changeset3 = create(:changeset, :min_lat => 4.5 * GeoRecord::SCALE, :min_lon => 4.5 * GeoRecord::SCALE, :max_lat => 5 * GeoRecord::SCALE, :max_lon => 5 * GeoRecord::SCALE)
1639
1640     get :query, :params => { :bbox => "-10,-10, 10, 10" }
1641     assert_response :success, "can't get changesets in bbox"
1642     assert_changesets [changeset2, changeset3]
1643
1644     get :query, :params => { :bbox => "4.5,4.5,4.6,4.6" }
1645     assert_response :success, "can't get changesets in bbox"
1646     assert_changesets [changeset3]
1647
1648     # not found when looking for changesets of non-existing users
1649     get :query, :params => { :user => User.maximum(:id) + 1 }
1650     assert_response :not_found
1651     get :query, :params => { :display_name => " " }
1652     assert_response :not_found
1653
1654     # can't get changesets of user 1 without authenticating
1655     get :query, :params => { :user => private_user.id }
1656     assert_response :not_found, "shouldn't be able to get changesets by non-public user (ID)"
1657     get :query, :params => { :display_name => private_user.display_name }
1658     assert_response :not_found, "shouldn't be able to get changesets by non-public user (name)"
1659
1660     # but this should work
1661     basic_authorization private_user.email, "test"
1662     get :query, :params => { :user => private_user.id }
1663     assert_response :success, "can't get changesets by user ID"
1664     assert_changesets [private_user_changeset, private_user_closed_changeset]
1665
1666     get :query, :params => { :display_name => private_user.display_name }
1667     assert_response :success, "can't get changesets by user name"
1668     assert_changesets [private_user_changeset, private_user_closed_changeset]
1669
1670     # check that the correct error is given when we provide both UID and name
1671     get :query, :params => { :user => private_user.id,
1672                              :display_name => private_user.display_name }
1673     assert_response :bad_request, "should be a bad request to have both ID and name specified"
1674
1675     get :query, :params => { :user => private_user.id, :open => true }
1676     assert_response :success, "can't get changesets by user and open"
1677     assert_changesets [private_user_changeset]
1678
1679     get :query, :params => { :time => "2007-12-31" }
1680     assert_response :success, "can't get changesets by time-since"
1681     assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3]
1682
1683     get :query, :params => { :time => "2008-01-01T12:34Z" }
1684     assert_response :success, "can't get changesets by time-since with hour"
1685     assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3]
1686
1687     get :query, :params => { :time => "2007-12-31T23:59Z,2008-01-02T00:01Z" }
1688     assert_response :success, "can't get changesets by time-range"
1689     assert_changesets [closed_changeset]
1690
1691     get :query, :params => { :open => "true" }
1692     assert_response :success, "can't get changesets by open-ness"
1693     assert_changesets [private_user_changeset, changeset, changeset2, changeset3]
1694
1695     get :query, :params => { :closed => "true" }
1696     assert_response :success, "can't get changesets by closed-ness"
1697     assert_changesets [private_user_closed_changeset, closed_changeset]
1698
1699     get :query, :params => { :closed => "true", :user => private_user.id }
1700     assert_response :success, "can't get changesets by closed-ness and user"
1701     assert_changesets [private_user_closed_changeset]
1702
1703     get :query, :params => { :closed => "true", :user => user.id }
1704     assert_response :success, "can't get changesets by closed-ness and user"
1705     assert_changesets [closed_changeset]
1706
1707     get :query, :params => { :changesets => "#{private_user_changeset.id},#{changeset.id},#{closed_changeset.id}" }
1708     assert_response :success, "can't get changesets by id (as comma-separated string)"
1709     assert_changesets [private_user_changeset, changeset, closed_changeset]
1710
1711     get :query, :params => { :changesets => "" }
1712     assert_response :bad_request, "should be a bad request since changesets is empty"
1713   end
1714
1715   ##
1716   # check that errors are returned if garbage is inserted
1717   # into query strings
1718   def test_query_invalid
1719     ["abracadabra!",
1720      "1,2,3,F",
1721      ";drop table users;"].each do |bbox|
1722       get :query, :params => { :bbox => bbox }
1723       assert_response :bad_request, "'#{bbox}' isn't a bbox"
1724     end
1725
1726     ["now()",
1727      "00-00-00",
1728      ";drop table users;",
1729      ",",
1730      "-,-"].each do |time|
1731       get :query, :params => { :time => time }
1732       assert_response :bad_request, "'#{time}' isn't a valid time range"
1733     end
1734
1735     ["me",
1736      "foobar",
1737      "-1",
1738      "0"].each do |uid|
1739       get :query, :params => { :user => uid }
1740       assert_response :bad_request, "'#{uid}' isn't a valid user ID"
1741     end
1742   end
1743
1744   ##
1745   # check updating tags on a changeset
1746   def test_changeset_update
1747     private_user = create(:user, :data_public => false)
1748     private_changeset = create(:changeset, :user => private_user)
1749     user = create(:user)
1750     changeset = create(:changeset, :user => user)
1751
1752     ## First try with a non-public user
1753     new_changeset = private_changeset.to_xml
1754     new_tag = XML::Node.new "tag"
1755     new_tag["k"] = "tagtesting"
1756     new_tag["v"] = "valuetesting"
1757     new_changeset.find("//osm/changeset").first << new_tag
1758     content new_changeset
1759
1760     # try without any authorization
1761     put :update, :params => { :id => private_changeset.id }
1762     assert_response :unauthorized
1763
1764     # try with the wrong authorization
1765     basic_authorization create(:user).email, "test"
1766     put :update, :params => { :id => private_changeset.id }
1767     assert_response :conflict
1768
1769     # now this should get an unauthorized
1770     basic_authorization private_user.email, "test"
1771     put :update, :params => { :id => private_changeset.id }
1772     assert_require_public_data "user with their data non-public, shouldn't be able to edit their changeset"
1773
1774     ## Now try with the public user
1775     create(:changeset_tag, :changeset => changeset)
1776     new_changeset = changeset.to_xml
1777     new_tag = XML::Node.new "tag"
1778     new_tag["k"] = "tagtesting"
1779     new_tag["v"] = "valuetesting"
1780     new_changeset.find("//osm/changeset").first << new_tag
1781     content new_changeset
1782
1783     # try without any authorization
1784     @request.env["HTTP_AUTHORIZATION"] = nil
1785     put :update, :params => { :id => changeset.id }
1786     assert_response :unauthorized
1787
1788     # try with the wrong authorization
1789     basic_authorization create(:user).email, "test"
1790     put :update, :params => { :id => changeset.id }
1791     assert_response :conflict
1792
1793     # now this should work...
1794     basic_authorization user.email, "test"
1795     put :update, :params => { :id => changeset.id }
1796     assert_response :success
1797
1798     assert_select "osm>changeset[id='#{changeset.id}']", 1
1799     assert_select "osm>changeset>tag", 2
1800     assert_select "osm>changeset>tag[k='tagtesting'][v='valuetesting']", 1
1801   end
1802
1803   ##
1804   # check that a user different from the one who opened the changeset
1805   # can't modify it.
1806   def test_changeset_update_invalid
1807     basic_authorization create(:user).email, "test"
1808
1809     changeset = create(:changeset)
1810     new_changeset = changeset.to_xml
1811     new_tag = XML::Node.new "tag"
1812     new_tag["k"] = "testing"
1813     new_tag["v"] = "testing"
1814     new_changeset.find("//osm/changeset").first << new_tag
1815
1816     content new_changeset
1817     put :update, :params => { :id => changeset.id }
1818     assert_response :conflict
1819   end
1820
1821   ##
1822   # check that a changeset can contain a certain max number of changes.
1823   ## FIXME should be changed to an integration test due to the with_controller
1824   def test_changeset_limits
1825     basic_authorization create(:user).email, "test"
1826
1827     # open a new changeset
1828     content "<osm><changeset/></osm>"
1829     put :create
1830     assert_response :success, "can't create a new changeset"
1831     cs_id = @response.body.to_i
1832
1833     # start the counter just short of where the changeset should finish.
1834     offset = 10
1835     # alter the database to set the counter on the changeset directly,
1836     # otherwise it takes about 6 minutes to fill all of them.
1837     changeset = Changeset.find(cs_id)
1838     changeset.num_changes = Changeset::MAX_ELEMENTS - offset
1839     changeset.save!
1840
1841     with_controller(NodeController.new) do
1842       # create a new node
1843       content "<osm><node changeset='#{cs_id}' lat='0.0' lon='0.0'/></osm>"
1844       put :create
1845       assert_response :success, "can't create a new node"
1846       node_id = @response.body.to_i
1847
1848       get :read, :params => { :id => node_id }
1849       assert_response :success, "can't read back new node"
1850       node_doc = XML::Parser.string(@response.body).parse
1851       node_xml = node_doc.find("//osm/node").first
1852
1853       # loop until we fill the changeset with nodes
1854       offset.times do |i|
1855         node_xml["lat"] = rand.to_s
1856         node_xml["lon"] = rand.to_s
1857         node_xml["version"] = (i + 1).to_s
1858
1859         content node_doc
1860         put :update, :params => { :id => node_id }
1861         assert_response :success, "attempt #{i} should have succeeded"
1862       end
1863
1864       # trying again should fail
1865       node_xml["lat"] = rand.to_s
1866       node_xml["lon"] = rand.to_s
1867       node_xml["version"] = offset.to_s
1868
1869       content node_doc
1870       put :update, :params => { :id => node_id }
1871       assert_response :conflict, "final attempt should have failed"
1872     end
1873
1874     changeset = Changeset.find(cs_id)
1875     assert_equal Changeset::MAX_ELEMENTS + 1, changeset.num_changes
1876
1877     # check that the changeset is now closed as well
1878     assert_not(changeset.is_open?,
1879                "changeset should have been auto-closed by exceeding " \
1880                "element limit.")
1881   end
1882
1883   ##
1884   # This should display the last 20 changesets closed
1885   def test_index
1886     get :index, :params => { :format => "html" }
1887     assert_response :success
1888     assert_template "history"
1889     assert_template :layout => "map"
1890     assert_select "h2", :text => "Changesets", :count => 1
1891
1892     get :index, :params => { :format => "html", :list => "1" }, :xhr => true
1893     assert_response :success
1894     assert_template "index"
1895
1896     check_index_result(Changeset.all)
1897   end
1898
1899   ##
1900   # This should display the last 20 changesets closed
1901   def test_index_xhr
1902     get :index, :params => { :format => "html" }, :xhr => true
1903     assert_response :success
1904     assert_template "history"
1905     assert_template :layout => "xhr"
1906     assert_select "h2", :text => "Changesets", :count => 1
1907
1908     get :index, :params => { :format => "html", :list => "1" }, :xhr => true
1909     assert_response :success
1910     assert_template "index"
1911
1912     check_index_result(Changeset.all)
1913   end
1914
1915   ##
1916   # This should display the last 20 changesets closed in a specific area
1917   def test_index_bbox
1918     get :index, :params => { :format => "html", :bbox => "4.5,4.5,5.5,5.5" }
1919     assert_response :success
1920     assert_template "history"
1921     assert_template :layout => "map"
1922     assert_select "h2", :text => "Changesets", :count => 1
1923
1924     get :index, :params => { :format => "html", :bbox => "4.5,4.5,5.5,5.5", :list => "1" }, :xhr => true
1925     assert_response :success
1926     assert_template "index"
1927
1928     check_index_result(Changeset.where("min_lon < 55000000 and max_lon > 45000000 and min_lat < 55000000 and max_lat > 45000000"))
1929   end
1930
1931   ##
1932   # Checks the display of the user changesets listing
1933   def test_index_user
1934     user = create(:user)
1935     create(:changeset, :user => user)
1936     create(:changeset, :closed, :user => user)
1937
1938     get :index, :params => { :format => "html", :display_name => user.display_name }
1939     assert_response :success
1940     assert_template "history"
1941
1942     get :index, :params => { :format => "html", :display_name => user.display_name, :list => "1" }, :xhr => true
1943     assert_response :success
1944     assert_template "index"
1945
1946     check_index_result(user.changesets)
1947   end
1948
1949   ##
1950   # Checks the display of the user changesets listing for a private user
1951   def test_index_private_user
1952     private_user = create(:user, :data_public => false)
1953     create(:changeset, :user => private_user)
1954     create(:changeset, :closed, :user => private_user)
1955
1956     get :index, :params => { :format => "html", :display_name => private_user.display_name }
1957     assert_response :success
1958     assert_template "history"
1959
1960     get :index, :params => { :format => "html", :display_name => private_user.display_name, :list => "1" }, :xhr => true
1961     assert_response :success
1962     assert_template "index"
1963
1964     check_index_result(Changeset.none)
1965   end
1966
1967   ##
1968   # Check the not found of the index user changesets
1969   def test_index_user_not_found
1970     get :index, :params => { :format => "html", :display_name => "Some random user" }
1971     assert_response :not_found
1972     assert_template "users/no_such_user"
1973
1974     get :index, :params => { :format => "html", :display_name => "Some random user", :list => "1" }, :xhr => true
1975     assert_response :not_found
1976     assert_template "users/no_such_user"
1977   end
1978
1979   ##
1980   # Checks the display of the friends changesets listing
1981   def test_index_friends
1982     private_user = create(:user, :data_public => true)
1983     friend = create(:friend, :befriender => private_user)
1984     create(:changeset, :user => friend.befriendee)
1985
1986     get :index, :params => { :friends => true }
1987     assert_response :redirect
1988     assert_redirected_to :controller => :users, :action => :login, :referer => friend_changesets_path
1989
1990     session[:user] = private_user.id
1991
1992     get :index, :params => { :friends => true }
1993     assert_response :success
1994     assert_template "history"
1995
1996     get :index, :params => { :friends => true, :list => "1" }, :xhr => true
1997     assert_response :success
1998     assert_template "index"
1999
2000     check_index_result(Changeset.where(:user => private_user.friend_users.identifiable))
2001   end
2002
2003   ##
2004   # Checks the display of the nearby user changesets listing
2005   def test_index_nearby
2006     private_user = create(:user, :data_public => false, :home_lat => 51.1, :home_lon => 1.0)
2007     user = create(:user, :home_lat => 51.0, :home_lon => 1.0)
2008     create(:changeset, :user => user)
2009
2010     get :index, :params => { :nearby => true }
2011     assert_response :redirect
2012     assert_redirected_to :controller => :users, :action => :login, :referer => nearby_changesets_path
2013
2014     session[:user] = private_user.id
2015
2016     get :index, :params => { :nearby => true }
2017     assert_response :success
2018     assert_template "history"
2019
2020     get :index, :params => { :nearby => true, :list => "1" }, :xhr => true
2021     assert_response :success
2022     assert_template "index"
2023
2024     check_index_result(Changeset.where(:user => user.nearby))
2025   end
2026
2027   ##
2028   # Check that we can't request later pages of the changesets index
2029   def test_index_max_id
2030     get :index, :params => { :format => "html", :max_id => 4 }, :xhr => true
2031     assert_response :success
2032     assert_template "history"
2033     assert_template :layout => "xhr"
2034     assert_select "h2", :text => "Changesets", :count => 1
2035
2036     get :index, :params => { :format => "html", :list => "1", :max_id => 4 }, :xhr => true
2037     assert_response :success
2038     assert_template "index"
2039
2040     check_index_result(Changeset.where("id <= 4"))
2041   end
2042
2043   ##
2044   # Check that a list with a next page link works
2045   def test_index_more
2046     create_list(:changeset, 50)
2047
2048     get :index, :params => { :format => "html" }
2049     assert_response :success
2050
2051     get :index, :params => { :format => "html" }, :xhr => true
2052     assert_response :success
2053   end
2054
2055   ##
2056   # This should display the last 20 non-empty changesets
2057   def test_feed
2058     changeset = create(:changeset, :num_changes => 1)
2059     create(:changeset_tag, :changeset => changeset)
2060     create(:changeset_tag, :changeset => changeset, :k => "website", :v => "http://example.com/")
2061     closed_changeset = create(:changeset, :closed, :num_changes => 1)
2062     _empty_changeset = create(:changeset, :num_changes => 0)
2063
2064     get :feed, :params => { :format => :atom }
2065     assert_response :success
2066     assert_template "index"
2067     assert_equal "application/atom+xml", response.content_type
2068
2069     check_feed_result([changeset, closed_changeset])
2070   end
2071
2072   ##
2073   # This should display the last 20 changesets closed in a specific area
2074   def test_feed_bbox
2075     changeset = create(:changeset, :num_changes => 1, :min_lat => 5 * GeoRecord::SCALE, :min_lon => 5 * GeoRecord::SCALE, :max_lat => 5 * GeoRecord::SCALE, :max_lon => 5 * GeoRecord::SCALE)
2076     create(:changeset_tag, :changeset => changeset)
2077     create(:changeset_tag, :changeset => changeset, :k => "website", :v => "http://example.com/")
2078     closed_changeset = create(:changeset, :closed, :num_changes => 1, :min_lat => 5 * GeoRecord::SCALE, :min_lon => 5 * GeoRecord::SCALE, :max_lat => 5 * GeoRecord::SCALE, :max_lon => 5 * GeoRecord::SCALE)
2079     _elsewhere_changeset = create(:changeset, :num_changes => 1, :min_lat => -5 * GeoRecord::SCALE, :min_lon => -5 * GeoRecord::SCALE, :max_lat => -5 * GeoRecord::SCALE, :max_lon => -5 * GeoRecord::SCALE)
2080     _empty_changeset = create(:changeset, :num_changes => 0, :min_lat => -5 * GeoRecord::SCALE, :min_lon => -5 * GeoRecord::SCALE, :max_lat => -5 * GeoRecord::SCALE, :max_lon => -5 * GeoRecord::SCALE)
2081
2082     get :feed, :params => { :format => :atom, :bbox => "4.5,4.5,5.5,5.5" }
2083     assert_response :success
2084     assert_template "index"
2085     assert_equal "application/atom+xml", response.content_type
2086
2087     check_feed_result([changeset, closed_changeset])
2088   end
2089
2090   ##
2091   # Checks the display of the user changesets feed
2092   def test_feed_user
2093     user = create(:user)
2094     changesets = create_list(:changeset, 3, :user => user, :num_changes => 4)
2095     create(:changeset_tag, :changeset => changesets[1])
2096     create(:changeset_tag, :changeset => changesets[1], :k => "website", :v => "http://example.com/")
2097     _other_changeset = create(:changeset)
2098
2099     get :feed, :params => { :format => :atom, :display_name => user.display_name }
2100
2101     assert_response :success
2102     assert_template "index"
2103     assert_equal "application/atom+xml", response.content_type
2104
2105     check_feed_result(changesets)
2106   end
2107
2108   ##
2109   # Check the not found of the user changesets feed
2110   def test_feed_user_not_found
2111     get :feed, :params => { :format => "atom", :display_name => "Some random user" }
2112     assert_response :not_found
2113   end
2114
2115   ##
2116   # Check that we can't request later pages of the changesets feed
2117   def test_feed_max_id
2118     get :feed, :params => { :format => "atom", :max_id => 100 }
2119     assert_response :redirect
2120     assert_redirected_to :action => :feed
2121   end
2122
2123   ##
2124   # check that the changeset download for a changeset with a redacted
2125   # element in it doesn't contain that element.
2126   def test_diff_download_redacted
2127     changeset = create(:changeset)
2128     node = create(:node, :with_history, :version => 2, :changeset => changeset)
2129     node_v1 = node.old_nodes.find_by(:version => 1)
2130     node_v1.redact!(create(:redaction))
2131
2132     get :download, :params => { :id => changeset.id }
2133     assert_response :success
2134
2135     assert_select "osmChange", 1
2136     # this changeset contains the node in versions 1 & 2, but 1 should
2137     # be hidden.
2138     assert_select "osmChange node[id='#{node.id}']", 1
2139     assert_select "osmChange node[id='#{node.id}'][version='1']", 0
2140   end
2141
2142   ##
2143   # create comment success
2144   def test_create_comment_success
2145     user = create(:user)
2146     user2 = create(:user)
2147     private_user = create(:user, :data_public => false)
2148     suspended_user = create(:user, :suspended)
2149     deleted_user = create(:user, :deleted)
2150     private_user_closed_changeset = create(:changeset, :closed, :user => private_user)
2151
2152     basic_authorization user.email, "test"
2153
2154     assert_difference "ChangesetComment.count", 1 do
2155       assert_no_difference "ActionMailer::Base.deliveries.size" do
2156         perform_enqueued_jobs do
2157           post :comment, :params => { :id => private_user_closed_changeset.id, :text => "This is a comment" }
2158         end
2159       end
2160     end
2161     assert_response :success
2162
2163     changeset = create(:changeset, :closed, :user => private_user)
2164     changeset.subscribers.push(private_user)
2165     changeset.subscribers.push(user)
2166     changeset.subscribers.push(suspended_user)
2167     changeset.subscribers.push(deleted_user)
2168
2169     assert_difference "ChangesetComment.count", 1 do
2170       assert_difference "ActionMailer::Base.deliveries.size", 1 do
2171         perform_enqueued_jobs do
2172           post :comment, :params => { :id => changeset.id, :text => "This is a comment" }
2173         end
2174       end
2175     end
2176     assert_response :success
2177
2178     email = ActionMailer::Base.deliveries.first
2179     assert_equal 1, email.to.length
2180     assert_equal "[OpenStreetMap] #{user.display_name} has commented on one of your changesets", email.subject
2181     assert_equal private_user.email, email.to.first
2182
2183     ActionMailer::Base.deliveries.clear
2184
2185     basic_authorization user2.email, "test"
2186
2187     assert_difference "ChangesetComment.count", 1 do
2188       assert_difference "ActionMailer::Base.deliveries.size", 2 do
2189         perform_enqueued_jobs do
2190           post :comment, :params => { :id => changeset.id, :text => "This is a comment" }
2191         end
2192       end
2193     end
2194     assert_response :success
2195
2196     email = ActionMailer::Base.deliveries.find { |e| e.to.first == private_user.email }
2197     assert_not_nil email
2198     assert_equal 1, email.to.length
2199     assert_equal "[OpenStreetMap] #{user2.display_name} has commented on one of your changesets", email.subject
2200
2201     email = ActionMailer::Base.deliveries.find { |e| e.to.first == user.email }
2202     assert_not_nil email
2203     assert_equal 1, email.to.length
2204     assert_equal "[OpenStreetMap] #{user2.display_name} has commented on a changeset you are interested in", email.subject
2205
2206     ActionMailer::Base.deliveries.clear
2207   end
2208
2209   ##
2210   # create comment fail
2211   def test_create_comment_fail
2212     # unauthorized
2213     post :comment, :params => { :id => create(:changeset, :closed).id, :text => "This is a comment" }
2214     assert_response :unauthorized
2215
2216     basic_authorization create(:user).email, "test"
2217
2218     # bad changeset id
2219     assert_no_difference "ChangesetComment.count" do
2220       post :comment, :params => { :id => 999111, :text => "This is a comment" }
2221     end
2222     assert_response :not_found
2223
2224     # not closed changeset
2225     assert_no_difference "ChangesetComment.count" do
2226       post :comment, :params => { :id => create(:changeset).id, :text => "This is a comment" }
2227     end
2228     assert_response :conflict
2229
2230     # no text
2231     assert_no_difference "ChangesetComment.count" do
2232       post :comment, :params => { :id => create(:changeset, :closed).id }
2233     end
2234     assert_response :bad_request
2235
2236     # empty text
2237     assert_no_difference "ChangesetComment.count" do
2238       post :comment, :params => { :id => create(:changeset, :closed).id, :text => "" }
2239     end
2240     assert_response :bad_request
2241   end
2242
2243   ##
2244   # test subscribe success
2245   def test_subscribe_success
2246     basic_authorization create(:user).email, "test"
2247     changeset = create(:changeset, :closed)
2248
2249     assert_difference "changeset.subscribers.count", 1 do
2250       post :subscribe, :params => { :id => changeset.id }
2251     end
2252     assert_response :success
2253
2254     # not closed changeset
2255     changeset = create(:changeset)
2256     assert_difference "changeset.subscribers.count", 1 do
2257       post :subscribe, :params => { :id => changeset.id }
2258     end
2259     assert_response :success
2260   end
2261
2262   ##
2263   # test subscribe fail
2264   def test_subscribe_fail
2265     user = create(:user)
2266
2267     # unauthorized
2268     changeset = create(:changeset, :closed)
2269     assert_no_difference "changeset.subscribers.count" do
2270       post :subscribe, :params => { :id => changeset.id }
2271     end
2272     assert_response :unauthorized
2273
2274     basic_authorization user.email, "test"
2275
2276     # bad changeset id
2277     assert_no_difference "changeset.subscribers.count" do
2278       post :subscribe, :params => { :id => 999111 }
2279     end
2280     assert_response :not_found
2281
2282     # trying to subscribe when already subscribed
2283     changeset = create(:changeset, :closed)
2284     changeset.subscribers.push(user)
2285     assert_no_difference "changeset.subscribers.count" do
2286       post :subscribe, :params => { :id => changeset.id }
2287     end
2288     assert_response :conflict
2289   end
2290
2291   ##
2292   # test unsubscribe success
2293   def test_unsubscribe_success
2294     user = create(:user)
2295     basic_authorization user.email, "test"
2296     changeset = create(:changeset, :closed)
2297     changeset.subscribers.push(user)
2298
2299     assert_difference "changeset.subscribers.count", -1 do
2300       post :unsubscribe, :params => { :id => changeset.id }
2301     end
2302     assert_response :success
2303
2304     # not closed changeset
2305     changeset = create(:changeset)
2306     changeset.subscribers.push(user)
2307
2308     assert_difference "changeset.subscribers.count", -1 do
2309       post :unsubscribe, :params => { :id => changeset.id }
2310     end
2311     assert_response :success
2312   end
2313
2314   ##
2315   # test unsubscribe fail
2316   def test_unsubscribe_fail
2317     # unauthorized
2318     changeset = create(:changeset, :closed)
2319     assert_no_difference "changeset.subscribers.count" do
2320       post :unsubscribe, :params => { :id => changeset.id }
2321     end
2322     assert_response :unauthorized
2323
2324     basic_authorization create(:user).email, "test"
2325
2326     # bad changeset id
2327     assert_no_difference "changeset.subscribers.count" do
2328       post :unsubscribe, :params => { :id => 999111 }
2329     end
2330     assert_response :not_found
2331
2332     # trying to unsubscribe when not subscribed
2333     changeset = create(:changeset, :closed)
2334     assert_no_difference "changeset.subscribers.count" do
2335       post :unsubscribe, :params => { :id => changeset.id }
2336     end
2337     assert_response :not_found
2338   end
2339
2340   ##
2341   # test hide comment fail
2342   def test_hide_comment_fail
2343     # unauthorized
2344     comment = create(:changeset_comment)
2345     assert_equal true, comment.visible
2346
2347     post :hide_comment, :params => { :id => comment.id }
2348     assert_response :unauthorized
2349     assert_equal true, comment.reload.visible
2350
2351     basic_authorization create(:user).email, "test"
2352
2353     # not a moderator
2354     post :hide_comment, :params => { :id => comment.id }
2355     assert_response :forbidden
2356     assert_equal true, comment.reload.visible
2357
2358     basic_authorization create(:moderator_user).email, "test"
2359
2360     # bad comment id
2361     post :hide_comment, :params => { :id => 999111 }
2362     assert_response :not_found
2363     assert_equal true, comment.reload.visible
2364   end
2365
2366   ##
2367   # test hide comment succes
2368   def test_hide_comment_success
2369     comment = create(:changeset_comment)
2370     assert_equal true, comment.visible
2371
2372     basic_authorization create(:moderator_user).email, "test"
2373
2374     post :hide_comment, :params => { :id => comment.id }
2375     assert_response :success
2376     assert_equal false, comment.reload.visible
2377   end
2378
2379   ##
2380   # test unhide comment fail
2381   def test_unhide_comment_fail
2382     # unauthorized
2383     comment = create(:changeset_comment, :visible => false)
2384     assert_equal false, comment.visible
2385
2386     post :unhide_comment, :params => { :id => comment.id }
2387     assert_response :unauthorized
2388     assert_equal false, comment.reload.visible
2389
2390     basic_authorization create(:user).email, "test"
2391
2392     # not a moderator
2393     post :unhide_comment, :params => { :id => comment.id }
2394     assert_response :forbidden
2395     assert_equal false, comment.reload.visible
2396
2397     basic_authorization create(:moderator_user).email, "test"
2398
2399     # bad comment id
2400     post :unhide_comment, :params => { :id => 999111 }
2401     assert_response :not_found
2402     assert_equal false, comment.reload.visible
2403   end
2404
2405   ##
2406   # test unhide comment succes
2407   def test_unhide_comment_success
2408     comment = create(:changeset_comment, :visible => false)
2409     assert_equal false, comment.visible
2410
2411     basic_authorization create(:moderator_user).email, "test"
2412
2413     post :unhide_comment, :params => { :id => comment.id }
2414     assert_response :success
2415     assert_equal true, comment.reload.visible
2416   end
2417
2418   ##
2419   # test comments feed
2420   def test_comments_feed
2421     changeset = create(:changeset, :closed)
2422     create_list(:changeset_comment, 3, :changeset => changeset)
2423
2424     get :comments_feed, :params => { :format => "rss" }
2425     assert_response :success
2426     assert_equal "application/rss+xml", @response.content_type
2427     assert_select "rss", :count => 1 do
2428       assert_select "channel", :count => 1 do
2429         assert_select "item", :count => 3
2430       end
2431     end
2432
2433     get :comments_feed, :params => { :format => "rss", :limit => 2 }
2434     assert_response :success
2435     assert_equal "application/rss+xml", @response.content_type
2436     assert_select "rss", :count => 1 do
2437       assert_select "channel", :count => 1 do
2438         assert_select "item", :count => 2
2439       end
2440     end
2441
2442     get :comments_feed, :params => { :id => changeset.id, :format => "rss" }
2443     assert_response :success
2444     assert_equal "application/rss+xml", @response.content_type
2445     assert_select "rss", :count => 1 do
2446       assert_select "channel", :count => 1 do
2447         assert_select "item", :count => 3
2448       end
2449     end
2450   end
2451
2452   ##
2453   # test comments feed
2454   def test_comments_feed_bad_limit
2455     get :comments_feed, :params => { :format => "rss", :limit => 0 }
2456     assert_response :bad_request
2457
2458     get :comments_feed, :params => { :format => "rss", :limit => 100001 }
2459     assert_response :bad_request
2460   end
2461
2462   private
2463
2464   ##
2465   # boilerplate for checking that certain changesets exist in the
2466   # output.
2467   def assert_changesets(changesets)
2468     assert_select "osm>changeset", changesets.size
2469     changesets.each do |changeset|
2470       assert_select "osm>changeset[id='#{changeset.id}']", 1
2471     end
2472   end
2473
2474   ##
2475   # call the include method and assert properties of the bbox
2476   def check_after_include(changeset_id, lon, lat, bbox)
2477     content "<osm><node lon='#{lon}' lat='#{lat}'/></osm>"
2478     post :expand_bbox, :params => { :id => changeset_id }
2479     assert_response :success, "Setting include of changeset failed: #{@response.body}"
2480
2481     # check exactly one changeset
2482     assert_select "osm>changeset", 1
2483     assert_select "osm>changeset[id='#{changeset_id}']", 1
2484
2485     # check the bbox
2486     doc = XML::Parser.string(@response.body).parse
2487     changeset = doc.find("//osm/changeset").first
2488     assert_equal bbox[0], changeset["min_lon"].to_f, "min lon"
2489     assert_equal bbox[1], changeset["min_lat"].to_f, "min lat"
2490     assert_equal bbox[2], changeset["max_lon"].to_f, "max lon"
2491     assert_equal bbox[3], changeset["max_lat"].to_f, "max lat"
2492   end
2493
2494   ##
2495   # update the changeset_id of a way element
2496   def update_changeset(xml, changeset_id)
2497     xml_attr_rewrite(xml, "changeset", changeset_id)
2498   end
2499
2500   ##
2501   # update an attribute in a way element
2502   def xml_attr_rewrite(xml, name, value)
2503     xml.find("//osm/way").first[name] = value.to_s
2504     xml
2505   end
2506
2507   ##
2508   # check the result of a index
2509   def check_index_result(changesets)
2510     changesets = changesets.where("num_changes > 0")
2511                            .order(:created_at => :desc)
2512                            .limit(20)
2513     assert changesets.size <= 20
2514
2515     assert_select "ol.changesets", :count => [changesets.size, 1].min do
2516       assert_select "li", :count => changesets.size
2517
2518       changesets.each do |changeset|
2519         assert_select "li#changeset_#{changeset.id}", :count => 1
2520       end
2521     end
2522   end
2523
2524   ##
2525   # check the result of a feed
2526   def check_feed_result(changesets)
2527     assert changesets.size <= 20
2528
2529     assert_select "feed", :count => [changesets.size, 1].min do
2530       assert_select "> title", :count => 1, :text => /^Changesets/
2531       assert_select "> entry", :count => changesets.size
2532
2533       changesets.each do |changeset|
2534         assert_select "> entry > id", changeset_url(:id => changeset.id)
2535       end
2536     end
2537   end
2538 end