Rework OpenID tests for new flows using OmniAuth mocking

[rails.git] / test / controllers / way_controller_test.rb

diff --git a/test/controllers/way_controller_test.rb b/test/controllers/way_controller_test.rb
index ca87e6543e6d96292d9e075307a34889e15ac7d8..ee68338891f3bd7119b9eb733775cc8278fe1609 100644 (file)
--- a/test/controllers/way_controller_test.rb
+++ b/test/controllers/way_controller_test.rb
@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'way_controller'
+require "test_helper"
+require "way_controller"

 
 class WayControllerTest < ActionController::TestCase
   api_fixtures
 
 class WayControllerTest < ActionController::TestCase
   api_fixtures


@@ -65,11 +65,11 @@ class WayControllerTest < ActionController::TestCase
 
       # otherwise it should say success
       assert_response :success
 
       # otherwise it should say success
       assert_response :success

-      
+

       # Check the way is correctly returned
       assert_select "osm way[id='#{way.id}'][version='#{way.version}'][visible='#{way.visible}']", 1
       # Check the way is correctly returned
       assert_select "osm way[id='#{way.id}'][version='#{way.version}'][visible='#{way.visible}']", 1

-      
-      # check that each node in the way appears once in the output as a 
+
+      # check that each node in the way appears once in the output as a

       # reference and as the node element.
       way.nodes.each do |n|
         count = (way.nodes - (way.nodes - [n])).length
       # reference and as the node element.
       way.nodes.each do |n|
         count = (way.nodes - (way.nodes - [n])).length


@@ -118,17 +118,15 @@ class WayControllerTest < ActionController::TestCase
 
     # use the first user's open changeset
     changeset_id = changesets(:normal_user_first_change).id
 
     # use the first user's open changeset
     changeset_id = changesets(:normal_user_first_change).id

-    
+

     # create a way with pre-existing nodes
     content "<osm><way changeset='#{changeset_id}'>" +
     # create a way with pre-existing nodes
     content "<osm><way changeset='#{changeset_id}'>" +

-      "<nd ref='#{nid1}'/><nd ref='#{nid2}'/>" + 
+      "<nd ref='#{nid1}'/><nd ref='#{nid2}'/>" +

       "<tag k='test' v='yes' /></way></osm>"
     put :create
       "<tag k='test' v='yes' /></way></osm>"
     put :create

-    # hope for success
-    assert_response :forbidden, 
-        "way upload did not return success status"
-    # read id of created way and search for it
-    wayid = @response.body
+    # hope for failure
+    assert_response :forbidden,
+                    "way upload did not return forbidden status"

 
     ## Now use a public user
     nid1 = current_nodes(:used_node_1).id
 
     ## Now use a public user
     nid1 = current_nodes(:used_node_1).id


@@ -137,33 +135,33 @@ class WayControllerTest < ActionController::TestCase
 
     # use the first user's open changeset
     changeset_id = changesets(:public_user_first_change).id
 
     # use the first user's open changeset
     changeset_id = changesets(:public_user_first_change).id

-    
+

     # create a way with pre-existing nodes
     content "<osm><way changeset='#{changeset_id}'>" +
     # create a way with pre-existing nodes
     content "<osm><way changeset='#{changeset_id}'>" +

-      "<nd ref='#{nid1}'/><nd ref='#{nid2}'/>" + 
+      "<nd ref='#{nid1}'/><nd ref='#{nid2}'/>" +

       "<tag k='test' v='yes' /></way></osm>"
     put :create
     # hope for success
       "<tag k='test' v='yes' /></way></osm>"
     put :create
     # hope for success

-    assert_response :success, 
-        "way upload did not return success status"
+    assert_response :success,
+                    "way upload did not return success status"

     # read id of created way and search for it
     wayid = @response.body
     checkway = Way.find(wayid)
     # read id of created way and search for it
     wayid = @response.body
     checkway = Way.find(wayid)

-    assert_not_nil checkway, 
-        "uploaded way not found in data base after upload"
+    assert_not_nil checkway,
+                   "uploaded way not found in data base after upload"

     # compare values
     # compare values

-    assert_equal checkway.nds.length, 2, 
-        "saved way does not contain exactly one node"
-    assert_equal checkway.nds[0], nid1, 
-        "saved way does not contain the right node on pos 0"
-    assert_equal checkway.nds[1], nid2, 
-        "saved way does not contain the right node on pos 1"
+    assert_equal checkway.nds.length, 2,
+                 "saved way does not contain exactly one node"
+    assert_equal checkway.nds[0], nid1,
+                 "saved way does not contain the right node on pos 0"
+    assert_equal checkway.nds[1], nid2,
+                 "saved way does not contain the right node on pos 1"

     assert_equal checkway.changeset_id, changeset_id,
     assert_equal checkway.changeset_id, changeset_id,

-        "saved way does not belong to the correct changeset"
-    assert_equal users(:public_user).id, checkway.changeset.user_id, 
-        "saved way does not belong to user that created it"
-    assert_equal true, checkway.visible, 
-        "saved way is not visible"
+                 "saved way does not belong to the correct changeset"
+    assert_equal users(:public_user).id, checkway.changeset.user_id,
+                 "saved way does not belong to user that created it"
+    assert_equal true, checkway.visible,
+                 "saved way is not visible"

   end
 
   # -------------------------------------
   end
 
   # -------------------------------------


@@ -180,30 +178,29 @@ class WayControllerTest < ActionController::TestCase
     nid1 = current_nodes(:used_node_1).id
 
     # create a way with non-existing node
     nid1 = current_nodes(:used_node_1).id
 
     # create a way with non-existing node

-    content "<osm><way changeset='#{open_changeset_id}'>" + 
+    content "<osm><way changeset='#{open_changeset_id}'>" +

       "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure
       "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure

-    assert_response :forbidden, 
-    "way upload with invalid node using a private user did not return 'forbidden'"
+    assert_response :forbidden,
+                    "way upload with invalid node using a private user did not return 'forbidden'"

 
     # create a way with no nodes
     content "<osm><way changeset='#{open_changeset_id}'>" +
       "<tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure
 
     # create a way with no nodes
     content "<osm><way changeset='#{open_changeset_id}'>" +
       "<tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure

-    assert_response :forbidden, 
-    "way upload with no node using a private userdid not return 'forbidden'"
+    assert_response :forbidden,
+                    "way upload with no node using a private userdid not return 'forbidden'"

 
     # create a way inside a closed changeset
     content "<osm><way changeset='#{closed_changeset_id}'>" +
       "<nd ref='#{nid1}'/></way></osm>"
     put :create
     # expect failure
 
     # create a way inside a closed changeset
     content "<osm><way changeset='#{closed_changeset_id}'>" +
       "<nd ref='#{nid1}'/></way></osm>"
     put :create
     # expect failure

-    assert_response :forbidden, 
-    "way upload to closed changeset with a private user did not return 'forbidden'"    
+    assert_response :forbidden,
+                    "way upload to closed changeset with a private user did not return 'forbidden'"

 
 

-    

     ## Now test with a public user
     basic_authorization users(:public_user).email, "test"
 
     ## Now test with a public user
     basic_authorization users(:public_user).email, "test"
 


@@ -213,12 +210,12 @@ class WayControllerTest < ActionController::TestCase
     nid1 = current_nodes(:used_node_1).id
 
     # create a way with non-existing node
     nid1 = current_nodes(:used_node_1).id
 
     # create a way with non-existing node

-    content "<osm><way changeset='#{open_changeset_id}'>" + 
+    content "<osm><way changeset='#{open_changeset_id}'>" +

       "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure
       "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure

-    assert_response :precondition_failed, 
-        "way upload with invalid node did not return 'precondition failed'"
+    assert_response :precondition_failed,
+                    "way upload with invalid node did not return 'precondition failed'"

     assert_equal "Precondition failed: Way  requires the nodes with id in (0), which either do not exist, or are not visible.", @response.body
 
     # create a way with no nodes
     assert_equal "Precondition failed: Way  requires the nodes with id in (0), which either do not exist, or are not visible.", @response.body
 
     # create a way with no nodes


@@ -226,8 +223,8 @@ class WayControllerTest < ActionController::TestCase
       "<tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure
       "<tag k='test' v='yes' /></way></osm>"
     put :create
     # expect failure

-    assert_response :precondition_failed, 
-        "way upload with no node did not return 'precondition failed'"
+    assert_response :precondition_failed,
+                    "way upload with no node did not return 'precondition failed'"

     assert_equal "Precondition failed: Cannot create way: data is invalid.", @response.body
 
     # create a way inside a closed changeset
     assert_equal "Precondition failed: Cannot create way: data is invalid.", @response.body
 
     # create a way inside a closed changeset


@@ -235,41 +232,41 @@ class WayControllerTest < ActionController::TestCase
       "<nd ref='#{nid1}'/></way></osm>"
     put :create
     # expect failure
       "<nd ref='#{nid1}'/></way></osm>"
     put :create
     # expect failure

-    assert_response :conflict, 
-        "way upload to closed changeset did not return 'conflict'"    
+    assert_response :conflict,
+                    "way upload to closed changeset did not return 'conflict'"

 
     # create a way with a tag which is too long
     content "<osm><way changeset='#{open_changeset_id}'>" +
       "<nd ref='#{nid1}'/>" +
 
     # create a way with a tag which is too long
     content "<osm><way changeset='#{open_changeset_id}'>" +
       "<nd ref='#{nid1}'/>" +

-      "<tag k='foo' v='#{'x'*256}'/>" +
+      "<tag k='foo' v='#{'x' * 256}'/>" +

       "</way></osm>"
     put :create
     # expect failure
       "</way></osm>"
     put :create
     # expect failure

-    assert_response :bad_request, 
-        "way upload to with too long tag did not return 'bad_request'"
+    assert_response :bad_request,
+                    "way upload to with too long tag did not return 'bad_request'"

   end
 
   # -------------------------------------
   # Test deleting ways.
   # -------------------------------------
   end
 
   # -------------------------------------
   # Test deleting ways.
   # -------------------------------------

-  
+

   def test_delete
     # first try to delete way without auth
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :unauthorized
 
     # now set auth using the private user
   def test_delete
     # first try to delete way without auth
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :unauthorized
 
     # now set auth using the private user

-    basic_authorization(users(:normal_user).email, "test");  
+    basic_authorization(users(:normal_user).email, "test")

 
     # this shouldn't work as with the 0.6 api we need pay load to delete
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :forbidden
 
     # this shouldn't work as with the 0.6 api we need pay load to delete
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :forbidden

-    
+

     # Now try without having a changeset
     content "<osm><way id='#{current_ways(:visible_way).id}'/></osm>"
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :forbidden
     # Now try without having a changeset
     content "<osm><way id='#{current_ways(:visible_way).id}'/></osm>"
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :forbidden

-    
+

     # try to delete with an invalid (closed) changeset
     content update_changeset(current_ways(:visible_way).to_xml,
                              changesets(:normal_user_closed_change).id)
     # try to delete with an invalid (closed) changeset
     content update_changeset(current_ways(:visible_way).to_xml,
                              changesets(:normal_user_closed_change).id)


@@ -277,7 +274,7 @@ class WayControllerTest < ActionController::TestCase
     assert_response :forbidden
 
     # try to delete with an invalid (non-existent) changeset
     assert_response :forbidden
 
     # try to delete with an invalid (non-existent) changeset

-    content update_changeset(current_ways(:visible_way).to_xml,0)
+    content update_changeset(current_ways(:visible_way).to_xml, 0)

     delete :delete, :id => current_ways(:visible_way).id
     assert_response :forbidden
 
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :forbidden
 


@@ -289,7 +286,7 @@ class WayControllerTest < ActionController::TestCase
     # check the returned value - should be the new version number
     # valid delete should return the new version number, which should
     # be greater than the old version number
     # check the returned value - should be the new version number
     # valid delete should return the new version number, which should
     # be greater than the old version number

-    #assert @response.body.to_i > current_ways(:visible_way).version,
+    # assert @response.body.to_i > current_ways(:visible_way).version,

     #   "delete request should return a new version number for way"
 
     # this won't work since the way is already deleted
     #   "delete request should return a new version number for way"
 
     # this won't work since the way is already deleted


@@ -300,27 +297,26 @@ class WayControllerTest < ActionController::TestCase
     # this shouldn't work as the way is used in a relation
     content current_ways(:used_way).to_xml
     delete :delete, :id => current_ways(:used_way).id
     # this shouldn't work as the way is used in a relation
     content current_ways(:used_way).to_xml
     delete :delete, :id => current_ways(:used_way).id

-    assert_response :forbidden, 
-    "shouldn't be able to delete a way used in a relation (#{@response.body}), when done by a private user"
+    assert_response :forbidden,
+                    "shouldn't be able to delete a way used in a relation (#{@response.body}), when done by a private user"

 
     # this won't work since the way never existed
     delete :delete, :id => 0
     assert_response :forbidden
 
 
     # this won't work since the way never existed
     delete :delete, :id => 0
     assert_response :forbidden
 

-    

     ### Now check with a public user
     # now set auth
     ### Now check with a public user
     # now set auth

-    basic_authorization(users(:public_user).email, "test");  
+    basic_authorization(users(:public_user).email, "test")

 
     # this shouldn't work as with the 0.6 api we need pay load to delete
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :bad_request
 
     # this shouldn't work as with the 0.6 api we need pay load to delete
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :bad_request

-    
+

     # Now try without having a changeset
     content "<osm><way id='#{current_ways(:visible_way).id}'/></osm>"
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :bad_request
     # Now try without having a changeset
     content "<osm><way id='#{current_ways(:visible_way).id}'/></osm>"
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :bad_request

-    
+

     # try to delete with an invalid (closed) changeset
     content update_changeset(current_ways(:visible_way).to_xml,
                              changesets(:public_user_closed_change).id)
     # try to delete with an invalid (closed) changeset
     content update_changeset(current_ways(:visible_way).to_xml,
                              changesets(:public_user_closed_change).id)


@@ -328,7 +324,7 @@ class WayControllerTest < ActionController::TestCase
     assert_response :conflict
 
     # try to delete with an invalid (non-existent) changeset
     assert_response :conflict
 
     # try to delete with an invalid (non-existent) changeset

-    content update_changeset(current_ways(:visible_way).to_xml,0)
+    content update_changeset(current_ways(:visible_way).to_xml, 0)

     delete :delete, :id => current_ways(:visible_way).id
     assert_response :conflict
 
     delete :delete, :id => current_ways(:visible_way).id
     assert_response :conflict
 


@@ -341,7 +337,7 @@ class WayControllerTest < ActionController::TestCase
     # valid delete should return the new version number, which should
     # be greater than the old version number
     assert @response.body.to_i > current_ways(:visible_way).version,
     # valid delete should return the new version number, which should
     # be greater than the old version number
     assert @response.body.to_i > current_ways(:visible_way).version,

-       "delete request should return a new version number for way"
+           "delete request should return a new version number for way"

 
     # this won't work since the way is already deleted
     content current_ways(:invisible_way).to_xml
 
     # this won't work since the way is already deleted
     content current_ways(:invisible_way).to_xml


@@ -351,8 +347,8 @@ class WayControllerTest < ActionController::TestCase
     # this shouldn't work as the way is used in a relation
     content current_ways(:used_way).to_xml
     delete :delete, :id => current_ways(:used_way).id
     # this shouldn't work as the way is used in a relation
     content current_ways(:used_way).to_xml
     delete :delete, :id => current_ways(:used_way).id

-    assert_response :precondition_failed, 
-       "shouldn't be able to delete a way used in a relation (#{@response.body})"
+    assert_response :precondition_failed,
+                    "shouldn't be able to delete a way used in a relation (#{@response.body})"

     assert_equal "Precondition failed: Way 3 is still used by relations 1.", @response.body
 
     # this won't work since the way never existed
     assert_equal "Precondition failed: Way 3 is still used by relations 1.", @response.body
 
     # this won't work since the way never existed


@@ -373,8 +369,8 @@ class WayControllerTest < ActionController::TestCase
 
     # add an identical tag to the way
     tag_xml = XML::Node.new("tag")
 
     # add an identical tag to the way
     tag_xml = XML::Node.new("tag")

-    tag_xml['k'] = current_way_tags(:t1).k
-    tag_xml['v'] = current_way_tags(:t1).v
+    tag_xml["k"] = current_way_tags(:t1).k
+    tag_xml["v"] = current_way_tags(:t1).v

 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml
 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml


@@ -383,8 +379,8 @@ class WayControllerTest < ActionController::TestCase
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id

-    assert_response :forbidden, 
-    "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
+    assert_response :forbidden,
+                    "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"

 
     ## Now try with the public user
     # setup auth
 
     ## Now try with the public user
     # setup auth


@@ -392,8 +388,8 @@ class WayControllerTest < ActionController::TestCase
 
     # add an identical tag to the way
     tag_xml = XML::Node.new("tag")
 
     # add an identical tag to the way
     tag_xml = XML::Node.new("tag")

-    tag_xml['k'] = current_way_tags(:t1).k
-    tag_xml['v'] = current_way_tags(:t1).v
+    tag_xml["k"] = current_way_tags(:t1).k
+    tag_xml["v"] = current_way_tags(:t1).v

 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml
 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml


@@ -402,8 +398,8 @@ class WayControllerTest < ActionController::TestCase
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id

-    assert_response :bad_request, 
-       "adding a duplicate tag to a way should fail with 'bad request'"
+    assert_response :bad_request,
+                    "adding a duplicate tag to a way should fail with 'bad request'"

     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{current_way_tags(:t1).k}", @response.body
   end
 
     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{current_way_tags(:t1).k}", @response.body
   end
 


@@ -416,8 +412,8 @@ class WayControllerTest < ActionController::TestCase
 
     # create duplicate tag
     tag_xml = XML::Node.new("tag")
 
     # create duplicate tag
     tag_xml = XML::Node.new("tag")

-    tag_xml['k'] = "i_am_a_duplicate"
-    tag_xml['v'] = "foobar"
+    tag_xml["k"] = "i_am_a_duplicate"
+    tag_xml["v"] = "foobar"

 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml
 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml


@@ -428,17 +424,17 @@ class WayControllerTest < ActionController::TestCase
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id

-    assert_response :forbidden, 
-    "adding new duplicate tags to a way using a non-public user should fail with 'forbidden'"
-    
+    assert_response :forbidden,
+                    "adding new duplicate tags to a way using a non-public user should fail with 'forbidden'"
+

     ## Now test with the public user
     # setup auth
     basic_authorization(users(:public_user).email, "test")
 
     # create duplicate tag
     tag_xml = XML::Node.new("tag")
     ## Now test with the public user
     # setup auth
     basic_authorization(users(:public_user).email, "test")
 
     # create duplicate tag
     tag_xml = XML::Node.new("tag")

-    tag_xml['k'] = "i_am_a_duplicate"
-    tag_xml['v'] = "foobar"
+    tag_xml["k"] = "i_am_a_duplicate"
+    tag_xml["v"] = "foobar"

 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml
 
     # add the tag into the existing xml
     way_xml = current_ways(:visible_way).to_xml


@@ -449,10 +445,9 @@ class WayControllerTest < ActionController::TestCase
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id
     # try and upload it
     content way_xml
     put :update, :id => current_ways(:visible_way).id

-    assert_response :bad_request, 
-       "adding new duplicate tags to a way should fail with 'bad request'"
+    assert_response :bad_request,
+                    "adding new duplicate tags to a way should fail with 'bad request'"

     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate", @response.body
     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate", @response.body

-    

   end
 
   ##
   end
 
   ##


@@ -468,14 +463,14 @@ class WayControllerTest < ActionController::TestCase
     way_str = "<osm><way changeset='1'>"
     way_str << "<tag k='addr:housenumber' v='1'/>"
     way_str << "<tag k='addr:housenumber' v='2'/>"
     way_str = "<osm><way changeset='1'>"
     way_str << "<tag k='addr:housenumber' v='1'/>"
     way_str << "<tag k='addr:housenumber' v='2'/>"

-    way_str << "</way></osm>";
+    way_str << "</way></osm>"

 
     # try and upload it
     content way_str
     put :create
 
     # try and upload it
     content way_str
     put :create

-    assert_response :forbidden, 
-    "adding new duplicate tags to a way with a non-public user should fail with 'forbidden'"
-    
+    assert_response :forbidden,
+                    "adding new duplicate tags to a way with a non-public user should fail with 'forbidden'"
+

     ## Now do it with a public user
     # setup auth
     basic_authorization(users(:public_user).email, "test")
     ## Now do it with a public user
     # setup auth
     basic_authorization(users(:public_user).email, "test")


@@ -484,13 +479,13 @@ class WayControllerTest < ActionController::TestCase
     way_str = "<osm><way changeset='1'>"
     way_str << "<tag k='addr:housenumber' v='1'/>"
     way_str << "<tag k='addr:housenumber' v='2'/>"
     way_str = "<osm><way changeset='1'>"
     way_str << "<tag k='addr:housenumber' v='1'/>"
     way_str << "<tag k='addr:housenumber' v='2'/>"

-    way_str << "</way></osm>";
+    way_str << "</way></osm>"

 
     # try and upload it
     content way_str
     put :create
 
     # try and upload it
     content way_str
     put :create

-    assert_response :bad_request, 
-    "adding new duplicate tags to a way should fail with 'bad request'"
+    assert_response :bad_request,
+                    "adding new duplicate tags to a way should fail with 'bad request'"

     assert_equal "Element way/ has duplicate tags with key addr:housenumber", @response.body
   end
 
     assert_equal "Element way/ has duplicate tags with key addr:housenumber", @response.body
   end
 


@@ -498,7 +493,7 @@ class WayControllerTest < ActionController::TestCase
   # test that a call to ways_for_node returns all ways that contain the node
   # and none that don't.
   def test_ways_for_node
   # test that a call to ways_for_node returns all ways that contain the node
   # and none that don't.
   def test_ways_for_node

-    # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4 
+    # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4

     # *used* to use it but doesn't.
     get :ways_for_node, :id => current_nodes(:used_node_1).id
     assert_response :success
     # *used* to use it but doesn't.
     get :ways_for_node, :id => current_nodes(:used_node_1).id
     assert_response :success


@@ -506,13 +501,13 @@ class WayControllerTest < ActionController::TestCase
     assert_not_nil ways_xml, "failed to parse ways_for_node response"
 
     # check that the set of IDs match expectations
     assert_not_nil ways_xml, "failed to parse ways_for_node response"
 
     # check that the set of IDs match expectations

-    expected_way_ids = [ current_ways(:visible_way).id,
-                         current_ways(:used_way).id
+    expected_way_ids = [current_ways(:visible_way).id,
+                        current_ways(:used_way).id

                        ]
     found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
     assert_equal expected_way_ids.sort, found_way_ids.sort,
                        ]
     found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
     assert_equal expected_way_ids.sort, found_way_ids.sort,

-      "expected ways for node #{current_nodes(:used_node_1).id} did not match found"
-    
+                 "expected ways for node #{current_nodes(:used_node_1).id} did not match found"
+

     # check the full ways to ensure we're not missing anything
     expected_way_ids.each do |id|
       way_xml = ways_xml.find("//osm/way[@id='#{id}']").first
     # check the full ways to ensure we're not missing anything
     expected_way_ids.each do |id|
       way_xml = ways_xml.find("//osm/way[@id='#{id}']").first


@@ -524,13 +519,13 @@ class WayControllerTest < ActionController::TestCase
   ##
   # update the changeset_id of a node element
   def update_changeset(xml, changeset_id)
   ##
   # update the changeset_id of a node element
   def update_changeset(xml, changeset_id)

-    xml_attr_rewrite(xml, 'changeset', changeset_id)
+    xml_attr_rewrite(xml, "changeset", changeset_id)

   end
 
   ##
   # update an attribute in the node element
   def xml_attr_rewrite(xml, name, value)
     xml.find("//osm/way").first[name] = value.to_s
   end
 
   ##
   # update an attribute in the node element
   def xml_attr_rewrite(xml, name, value)
     xml.find("//osm/way").first[name] = value.to_s

-    return xml
+    xml

   end
 end
   end
 end