Log the request on a few requests when there is a bad request, probably should do...

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

diff --git a/test/functional/way_controller_test.rb b/test/functional/way_controller_test.rb
index 0eb77c2e44e4f383a06f18a912d28184f2b683ee..40ac0bd71c2388447c7fae9d4b44d58d92f18d85 100644 (file)
--- a/test/functional/way_controller_test.rb
+++ b/test/functional/way_controller_test.rb
@@ -1,18 +1,9 @@
 require File.dirname(__FILE__) + '/../test_helper'
 require 'way_controller'
 
 require File.dirname(__FILE__) + '/../test_helper'
 require 'way_controller'
 

-# Re-raise errors caught by the controller.
-class WayController; def rescue_action(e) raise e end; end
-
-class WayControllerTest < Test::Unit::TestCase
+class WayControllerTest < ActionController::TestCase

   api_fixtures
 
   api_fixtures
 

-  def setup
-    @controller = WayController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-  end
-

   def basic_authorization(user, pass)
     @request.env["HTTP_AUTHORIZATION"] = "Basic %s" % Base64.encode64("#{user}:#{pass}")
   end
   def basic_authorization(user, pass)
     @request.env["HTTP_AUTHORIZATION"] = "Basic %s" % Base64.encode64("#{user}:#{pass}")
   end


@@ -37,34 +28,35 @@ class WayControllerTest < Test::Unit::TestCase
     # check chat a non-existent way is not returned
     get :read, :id => 0
     assert_response :not_found
     # check chat a non-existent way is not returned
     get :read, :id => 0
     assert_response :not_found

+  end

 
 

-    # check the "ways for node" mode
-    get :ways_for_node, :id => current_nodes(:used_node_1).id
-    assert_response :success
-    # FIXME check whether this contains the stuff we want!
-    #print @response.body
-    # Needs to be updated when changing fixtures
-    # The generator should probably be defined in the environment.rb file
-    # in the same place as the api version
-    assert_select "osm[version=#{API_VERSION}][generator=\"OpenStreetMap server\"]", 1
-    assert_select "osm way", 3
-    assert_select "osm way nd", 3
-    assert_select "osm way tag", 3
-
-    # check the "full" mode
-    get :full, :id => current_ways(:visible_way).id
-    assert_response :success
-    # FIXME check whether this contains the stuff we want!
-    #print @response.body
-    # Check the way is correctly returned
-    way = current_ways(:visible_way)
-    assert_select "osm way[id=#{way.id}][version=#{way.version}][visible=#{way.visible}]", 1
-    assert_select "osm way nd[ref=#{way.way_nodes[0].node_id}]", 1
-    # Check that the node is correctly returned
-    nd = current_ways(:visible_way).nodes
-    assert_equal 1, nd.count
-    nda = nd[0]
-    assert_select "osm node[id=#{nda.id}][version=#{nda.version}][lat=#{nda.lat}][lon=#{nda.lon}]", 1 
+  ##
+  # check the "full" mode
+  def test_full
+    Way.find(:all).each do |way|
+      get :full, :id => way.id
+
+      # full call should say "gone" for non-visible ways...
+      unless way.visible
+        assert_response :gone
+        next
+      end
+
+      # 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 that each node in the way appears once in the output as a 
+      # reference and as the node element. note the slightly dodgy assumption
+      # that nodes appear only once. this is currently the case with the
+      # fixtures, but it doesn't have to be.
+      way.nodes.each do |n|
+        assert_select "osm way nd[ref=#{n.id}]", 1
+        assert_select "osm node[id=#{n.id}][version=#{n.version}][lat=#{n.lat}][lon=#{n.lon}]", 1
+      end
+    end

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


@@ -227,6 +219,7 @@ class WayControllerTest < Test::Unit::TestCase
     put :update, :id => current_ways(:visible_way).id
     assert_response :bad_request, 
        "adding a duplicate tag to a way should fail with 'bad request'"
     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_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{current_way_tags(:t1).k}.", @response.body

   end
 
   ##
   end
 
   ##


@@ -251,16 +244,13 @@ class WayControllerTest < Test::Unit::TestCase
     put :update, :id => current_ways(:visible_way).id
     assert_response :bad_request, 
        "adding new duplicate tags to a way should fail with 'bad request'"
     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_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate.", @response.body

   end
 
   ##
   # Try adding a new duplicate tags to a way.
   # But be a bit subtle - use unicode decoding ambiguities to use different
   # binary strings which have the same decoding.
   end
 
   ##
   # Try adding a new duplicate tags to a way.
   # But be a bit subtle - use unicode decoding ambiguities to use different
   # binary strings which have the same decoding.

-  #
-  # NOTE: I'm not sure this test is working correctly, as a lot of the tag
-  # keys seem to come out as "addr��housenumber". It might be something to
-  # do with Ruby's unicode handling...?

   def test_invalid_duplicate_tags
     # setup auth
     basic_authorization(users(:normal_user).email, "test")
   def test_invalid_duplicate_tags
     # setup auth
     basic_authorization(users(:normal_user).email, "test")


@@ -268,25 +258,41 @@ class WayControllerTest < Test::Unit::TestCase
     # add the tag into the existing xml
     way_str = "<osm><way changeset='1'>"
     way_str << "<tag k='addr:housenumber' v='1'/>"
     # add the tag into the existing xml
     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>";

 
 

-    # all of these keys have the same unicode decoding, but are binary
-    # not equal. libxml should make these identical as it decodes the
-    # XML document...
-    [ "addr\xc0\xbahousenumber",
-      "addr\xe0\x80\xbahousenumber",
-      "addr\xf0\x80\x80\xbahousenumber" ].each do |key|
-      # copy the XML doc to add the tags
-      way_str_copy = way_str.clone
-
-      # add all new tags to the way
-      way_str_copy << "<tag k='" << key << "' v='1'/>"
-      way_str_copy << "</way></osm>";
-
-      # try and upload it
-      content way_str_copy
-      put :create
-      assert_response :bad_request, 
-         "adding new duplicate tags to a way should fail with 'bad request'"
+    # 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_equal "Element way/ has duplicate tags with key addr:housenumber.", @response.body
+  end
+
+  ##
+  # 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 
+    # *used* to use it but doesn't.
+    get :ways_for_node, :id => current_nodes(:used_node_1).id
+    assert_response :success
+    ways_xml = XML::Parser.string(@response.body).parse
+    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
+                       ]
+    found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
+    assert_equal expected_way_ids, found_way_ids,
+      "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
+      assert_ways_are_equal(Way.find(id),
+                            Way.from_xml_node(way_xml))

     end
   end
 
     end
   end