Merge remote-tracking branch 'upstream/pull/5050'

diff --combined test/controllers/api/changesets_controller_test.rb
index 026d55d4801b252d9d875e3117222c7040f7ca15,d8e4f7ffb427499898f18c16f066be0e917331c1..1d7afa03586130e5041b17a4722857a97f5561cf
--- 1/test/controllers/api/changesets_controller_test.rb
--- 2/test/controllers/api/changesets_controller_test.rb
+++ b/test/controllers/api/changesets_controller_test.rb
@@@ -636,26 -636,27 +636,27 @@@ module Ap
                        "can't upload a simple valid creation to changeset: #{@response.body}"
  
        # check the returned payload
-       assert_select "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1
-       assert_select "diffResult>node", 1
-       assert_select "diffResult>way", 1
-       assert_select "diffResult>relation", 1
- 
-       # inspect the response to find out what the new element IDs are
-       doc = XML::Parser.string(@response.body).parse
-       new_node_id = doc.find("//diffResult/node").first["new_id"].to_i
-       new_way_id = doc.find("//diffResult/way").first["new_id"].to_i
-       new_rel_id = doc.find("//diffResult/relation").first["new_id"].to_i
- 
-       # check the old IDs are all present and negative one
-       assert_equal(-1, doc.find("//diffResult/node").first["old_id"].to_i)
-       assert_equal(-1, doc.find("//diffResult/way").first["old_id"].to_i)
-       assert_equal(-1, doc.find("//diffResult/relation").first["old_id"].to_i)
- 
-       # check the versions are present and equal one
-       assert_equal 1, doc.find("//diffResult/node").first["new_version"].to_i
-       assert_equal 1, doc.find("//diffResult/way").first["new_version"].to_i
-       assert_equal 1, doc.find("//diffResult/relation").first["new_version"].to_i
+       new_node_id, new_way_id, new_rel_id = nil
+       assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
+         # inspect the response to find out what the new element IDs are
+         # check the old IDs are all present and negative one
+         # check the versions are present and equal one
+         assert_dom "> node", 1 do |(node_el)|
+           new_node_id = node_el["new_id"].to_i
+           assert_dom "> @old_id", "-1"
+           assert_dom "> @new_version", "1"
+         end
+         assert_dom "> way", 1 do |(way_el)|
+           new_way_id = way_el["new_id"].to_i
+           assert_dom "> @old_id", "-1"
+           assert_dom "> @new_version", "1"
+         end
+         assert_dom "> relation", 1 do |(rel_el)|
+           new_rel_id = rel_el["new_id"].to_i
+           assert_dom "> @old_id", "-1"
+           assert_dom "> @new_version", "1"
+         end
+       end
  
        # check that the changes made it into the database
        assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
@@@ -878,28 -879,26 +879,26 @@@
                        "can't do a conditional delete of in use objects: #{@response.body}"
  
        # check the returned payload
-       assert_select "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1
-       assert_select "diffResult>node", 1
-       assert_select "diffResult>way", 1
-       assert_select "diffResult>relation", 1
- 
-       # parse the response
-       doc = XML::Parser.string(@response.body).parse
- 
-       # check the old IDs are all present and what we expect
-       assert_equal used_node.id, doc.find("//diffResult/node").first["old_id"].to_i
-       assert_equal used_way.id, doc.find("//diffResult/way").first["old_id"].to_i
-       assert_equal used_relation.id, doc.find("//diffResult/relation").first["old_id"].to_i
- 
-       # check the new IDs are all present and unchanged
-       assert_equal used_node.id, doc.find("//diffResult/node").first["new_id"].to_i
-       assert_equal used_way.id, doc.find("//diffResult/way").first["new_id"].to_i
-       assert_equal used_relation.id, doc.find("//diffResult/relation").first["new_id"].to_i
- 
-       # check the new versions are all present and unchanged
-       assert_equal used_node.version, doc.find("//diffResult/node").first["new_version"].to_i
-       assert_equal used_way.version, doc.find("//diffResult/way").first["new_version"].to_i
-       assert_equal used_relation.version, doc.find("//diffResult/relation").first["new_version"].to_i
+       assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
+         # check the old IDs are all present and what we expect
+         # check the new IDs are all present and unchanged
+         # check the new versions are all present and unchanged
+         assert_dom "> node", 1 do
+           assert_dom "> @old_id", used_node.id.to_s
+           assert_dom "> @new_id", used_node.id.to_s
+           assert_dom "> @new_version", used_node.version.to_s
+         end
+         assert_dom "> way", 1 do
+           assert_dom "> @old_id", used_way.id.to_s
+           assert_dom "> @new_id", used_way.id.to_s
+           assert_dom "> @new_version", used_way.version.to_s
+         end
+         assert_dom "> relation", 1 do
+           assert_dom "> @old_id", used_relation.id.to_s
+           assert_dom "> @new_id", used_relation.id.to_s
+           assert_dom "> @new_version", used_relation.version.to_s
+         end
+       end
  
        # check that nothing was, in fact, deleted
        assert Node.find(used_node.id).visible
@@@ -973,14 -972,14 +972,14 @@@
                        "can't upload a complex diff to changeset: #{@response.body}"
  
        # check the returned payload
-       assert_select "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1
-       assert_select "diffResult>node", 1
-       assert_select "diffResult>way", 1
-       assert_select "diffResult>relation", 1
- 
-       # inspect the response to find out what the new element IDs are
-       doc = XML::Parser.string(@response.body).parse
-       new_node_id = doc.find("//diffResult/node").first["new_id"].to_i
+       new_node_id = nil
+       assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
+         assert_dom "> node", 1 do |(node_el)|
+           new_node_id = node_el["new_id"].to_i
+         end
+         assert_dom "> way", 1
+         assert_dom "> relation", 1
+       end
  
        # check that the changes made it into the database
        assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
@@@ -2173,11 -2172,11 +2172,11 @@@
  
        get changesets_path(:bbox => "-10,-10, 10, 10")
        assert_response :success, "can't get changesets in bbox"
 -      assert_changesets [changeset2, changeset3]
 +      assert_changesets_in_order [changeset3, changeset2]
  
        get changesets_path(:bbox => "4.5,4.5,4.6,4.6")
        assert_response :success, "can't get changesets in bbox"
 -      assert_changesets [changeset3]
 +      assert_changesets_in_order [changeset3]
  
        # not found when looking for changesets of non-existing users
        get changesets_path(:user => User.maximum(:id) + 1)
@@@ -2197,11 -2196,11 +2196,11 @@@
        auth_header = basic_authorization_header private_user.email, "test"
        get changesets_path(:user => private_user.id), :headers => auth_header
        assert_response :success, "can't get changesets by user ID"
 -      assert_changesets [private_user_changeset, private_user_closed_changeset]
 +      assert_changesets_in_order [private_user_changeset, private_user_closed_changeset]
  
        get changesets_path(:display_name => private_user.display_name), :headers => auth_header
        assert_response :success, "can't get changesets by user name"
 -      assert_changesets [private_user_changeset, private_user_closed_changeset]
 +      assert_changesets_in_order [private_user_changeset, private_user_closed_changeset]
  
        # test json endpoint
        get changesets_path(:display_name => private_user.display_name), :headers => auth_header, :params => { :format => "json" }
@@@ -2221,39 -2220,39 +2220,39 @@@
  
        get changesets_path(:user => private_user.id, :open => true), :headers => auth_header
        assert_response :success, "can't get changesets by user and open"
 -      assert_changesets [private_user_changeset]
 +      assert_changesets_in_order [private_user_changeset]
  
        get changesets_path(:time => "2007-12-31"), :headers => auth_header
        assert_response :success, "can't get changesets by time-since"
 -      assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3]
 +      assert_changesets_in_order [changeset3, changeset2, changeset, private_user_changeset, private_user_closed_changeset, closed_changeset]
  
        get changesets_path(:time => "2008-01-01T12:34Z"), :headers => auth_header
        assert_response :success, "can't get changesets by time-since with hour"
 -      assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3]
 +      assert_changesets_in_order [changeset3, changeset2, changeset, private_user_changeset, private_user_closed_changeset, closed_changeset]
  
        get changesets_path(:time => "2007-12-31T23:59Z,2008-01-02T00:01Z"), :headers => auth_header
        assert_response :success, "can't get changesets by time-range"
 -      assert_changesets [closed_changeset]
 +      assert_changesets_in_order [closed_changeset]
  
        get changesets_path(:open => "true"), :headers => auth_header
        assert_response :success, "can't get changesets by open-ness"
 -      assert_changesets [private_user_changeset, changeset, changeset2, changeset3]
 +      assert_changesets_in_order [changeset3, changeset2, changeset, private_user_changeset]
  
        get changesets_path(:closed => "true"), :headers => auth_header
        assert_response :success, "can't get changesets by closed-ness"
 -      assert_changesets [private_user_closed_changeset, closed_changeset]
 +      assert_changesets_in_order [private_user_closed_changeset, closed_changeset]
  
        get changesets_path(:closed => "true", :user => private_user.id), :headers => auth_header
        assert_response :success, "can't get changesets by closed-ness and user"
 -      assert_changesets [private_user_closed_changeset]
 +      assert_changesets_in_order [private_user_closed_changeset]
  
        get changesets_path(:closed => "true", :user => user.id), :headers => auth_header
        assert_response :success, "can't get changesets by closed-ness and user"
 -      assert_changesets [closed_changeset]
 +      assert_changesets_in_order [closed_changeset]
  
        get changesets_path(:changesets => "#{private_user_changeset.id},#{changeset.id},#{closed_changeset.id}"), :headers => auth_header
        assert_response :success, "can't get changesets by id (as comma-separated string)"
 -      assert_changesets [private_user_changeset, changeset, closed_changeset]
 +      assert_changesets_in_order [changeset, private_user_changeset, closed_changeset]
  
        get changesets_path(:changesets => ""), :headers => auth_header
        assert_response :bad_request, "should be a bad request since changesets is empty"
@@@ -2683,6 -2682,15 +2682,6 @@@
        end
      end
  
 -    ##
 -    # check that certain changesets exist in the output
 -    def assert_changesets(changesets)
 -      assert_select "osm>changeset", changesets.size
 -      changesets.each do |changeset|
 -        assert_select "osm>changeset[id='#{changeset.id}']", 1
 -      end
 -    end
 -
      ##
      # check that certain changesets exist in the output in the specified order
      def assert_changesets_in_order(changesets)