From eebadd141a6b0aa067131d6ae807fae5f4d3c07b Mon Sep 17 00:00:00 2001 From: Dave Stubbs Date: Sat, 8 Nov 2008 19:41:29 +0000 Subject: [PATCH] 1st amf_controller tests, and some basic sanity check fixes --- app/controllers/amf_controller.rb | 59 +++++-- test/functional/amf_controller_test.rb | 213 ++++++++++++++++++++++++- 2 files changed, 257 insertions(+), 15 deletions(-) diff --git a/app/controllers/amf_controller.rb b/app/controllers/amf_controller.rb index 935746ed4..0e77c11f7 100644 --- a/app/controllers/amf_controller.rb +++ b/app/controllers/amf_controller.rb @@ -28,6 +28,9 @@ class AmfController < ApplicationController include Potlatch + # Help methods for checking boundary sanity and area size + include MapBoundary + session :off before_filter :check_write_availability @@ -128,6 +131,15 @@ class AmfController < ApplicationController def whichways(xmin, ymin, xmax, ymax) #:doc: xmin -= 0.01; ymin -= 0.01 xmax += 0.01; ymax += 0.01 + + # check boundary is sane and area within defined + # see /config/application.yml + begin + check_boundaries(xmin, ymin, xmax, ymax) + rescue Exception => err + # FIXME: report an error rather than just return an empty result + return [[],[],[]] + end if POTLATCH_USE_SQL then way_ids = sql_find_way_ids_in_area(xmin, ymin, xmax, ymax) @@ -135,7 +147,7 @@ class AmfController < ApplicationController relation_ids = sql_find_relations_in_area_and_ways(xmin, ymin, xmax, ymax, way_ids) else # find the way ids in an area - nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 1", :include => :ways) + nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_nodes.visible = ?", true], :include => :ways) way_ids = nodes_in_area.collect { |node| node.way_ids }.flatten.uniq # find the node ids in an area that aren't part of ways @@ -143,8 +155,8 @@ class AmfController < ApplicationController points = nodes_not_used_in_area.collect { |n| [n.id, n.lon, n.lat, n.tags_as_hash] } # find the relations used by those nodes and ways - relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => "visible = 1") + - Relation.find_for_ways(way_ids, :conditions => "visible = 1") + relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => {:visible => true}) + + Relation.find_for_ways(way_ids, :conditions => {:visible => true}) relation_ids = relations.collect { |relation| relation.id }.uniq end @@ -158,7 +170,16 @@ class AmfController < ApplicationController xmin -= 0.01; ymin -= 0.01 xmax += 0.01; ymax += 0.01 - nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 0 AND current_ways.visible = 0", :include => :ways_via_history) + # check boundary is sane and area within defined + # see /config/application.yml + begin + check_boundaries(xmin, ymin, xmax, ymax) + rescue Exception => err + # FIXME: report an error rather than just return an empty result + return [[]] + end + + nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_ways.visible = ?", false], :include => :ways_via_history) way_ids = nodes_in_area.collect { |node| node.ways_via_history_ids }.flatten.uniq [way_ids] @@ -175,7 +196,15 @@ class AmfController < ApplicationController # Ideally we would do ":include => :nodes" here but if we do that # then rails only seems to return the first copy of a node when a # way includes a node more than once - way = Way.find(wayid) + begin + way = Way.find(wayid) + rescue ActiveRecord::RecordNotFound + return [wayid,[],{}] + end + + # check case where way has been deleted or doesn't exist + return [wayid,[],{}] if way.nil? or !way.visible + points = way.nodes.collect do |node| nodetags=node.tags_as_hash nodetags.delete('created_by') @@ -196,7 +225,7 @@ class AmfController < ApplicationController def getway_old(id, version) #:doc: if version < 0 - old_way = OldWay.find(:first, :conditions => ['visible = 1 AND id = ?', id], :order => 'version DESC') + old_way = OldWay.find(:first, :conditions => ['visible = ? AND id = ?', true, id], :order => 'version DESC') points = old_way.get_nodes_undelete else old_way = OldWay.find(:first, :conditions => ['id = ? AND version = ?', id, version]) @@ -241,7 +270,13 @@ class AmfController < ApplicationController # 2. list of members. def getrelation(relid) #:doc: - rel = Relation.find(relid) + begin + rel = Relation.find(relid) + rescue ActiveRecord::RecordNotFound + return [relid, {}, []] + end + + return [relid, {}, []] if rel.nil? or !rel.visible [relid, rel.tags, rel.members] end @@ -277,7 +312,7 @@ class AmfController < ApplicationController if !uid then return -1,"You are not logged in, so the relation could not be saved." end relid = relid.to_i - visible = visible.to_i + visible = (visible.to_i != 0) # create a new relation, or find the existing one if relid <= 0 @@ -563,8 +598,8 @@ class AmfController < ApplicationController FROM current_way_nodes INNER JOIN current_nodes ON current_nodes.id=current_way_nodes.node_id INNER JOIN current_ways ON current_ways.id =current_way_nodes.id - WHERE current_nodes.visible=1 - AND current_ways.visible=1 + WHERE current_nodes.visible=TRUE + AND current_ways.visible=TRUE AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")} EOF return ActiveRecord::Base.connection.select_all(sql).collect { |a| a['wayid'].to_i } @@ -575,7 +610,7 @@ class AmfController < ApplicationController SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lon,current_nodes.tags FROM current_nodes LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id - WHERE current_nodes.visible=1 + WHERE current_nodes.visible=TRUE AND cwn.id IS NULL AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")} EOF @@ -612,7 +647,7 @@ class AmfController < ApplicationController FROM current_way_nodes,current_nodes WHERE current_way_nodes.id=#{wayid.to_i} AND current_way_nodes.node_id=current_nodes.id - AND current_nodes.visible=1 + AND current_nodes.visible=TRUE ORDER BY sequence_id EOF ActiveRecord::Base.connection.select_all(sql).each do |row| diff --git a/test/functional/amf_controller_test.rb b/test/functional/amf_controller_test.rb index 1d17a5bea..e0375c92f 100644 --- a/test/functional/amf_controller_test.rb +++ b/test/functional/amf_controller_test.rb @@ -1,8 +1,215 @@ require File.dirname(__FILE__) + '/../test_helper' +require 'stringio' +include Potlatch class AmfControllerTest < ActionController::TestCase - # Replace this with your real tests. - def test_truth - assert true + api_fixtures + + def test_getway + # check a visible way + id = current_ways(:visible_way).id + amf_content "getway", "/1", [id] + post :amf_read + assert_response :success + amf_parse_response + assert_equal amf_result("/1")[0], id + end + + def test_getway_invisible + # check an invisible way + id = current_ways(:invisible_way).id + amf_content "getway", "/1", [id] + post :amf_read + assert_response :success + amf_parse_response + way = amf_result("/1") + assert_equal way[0], id + assert way[1].empty? and way[2].empty? + end + + def test_getway_nonexistent + # check chat a non-existent way is not returned + amf_content "getway", "/1", [0] + post :amf_read + assert_response :success + amf_parse_response + way = amf_result("/1") + assert_equal way[0], 0 + assert way[1].empty? and way[2].empty? + end + + def test_whichways + node = current_nodes(:used_node_1) + minlon = node.lon-0.1 + minlat = node.lat-0.1 + maxlon = node.lon+0.1 + maxlat = node.lat+0.1 + amf_content "whichways", "/1", [minlon, minlat, maxlon, maxlat] + post :amf_read + assert_response :success + amf_parse_response + + # check contents of message + map = amf_result "/1" + assert map[0].include?(current_ways(:used_way).id) + assert !map[0].include?(current_ways(:invisible_way).id) + end + + def test_whichways_toobig + bbox = [-0.1,-0.1,1.1,1.1] + amf_content "whichways", "/1", bbox + post :amf_read + assert_response :success + amf_parse_response + + # FIXME: whichways needs to reject large bboxes and the test needs to check for this + map = amf_result "/1" + assert map[0].empty? and map[1].empty? and map[2].empty? + end + + def test_whichways_badlat + bboxes = [[0,0.1,0.1,0], [-0.1,80,0.1,70], [0.24,54.34,0.25,54.33]] + bboxes.each do |bbox| + amf_content "whichways", "/1", bbox + post :amf_read + assert_response :success + amf_parse_response + + # FIXME: whichways needs to reject bboxes with illegal lats and the test needs to check for this + map = amf_result "/1" + assert map[0].empty? and map[1].empty? and map[2].empty? + end + end + + def test_whichways_badlon + bboxes = [[80,-0.1,70,0.1], [54.34,0.24,54.33,0.25]] + bboxes.each do |bbox| + amf_content "whichways", "/1", bbox + post :amf_read + assert_response :success + amf_parse_response + + # FIXME: whichways needs to reject bboxes with illegal lons and the test needs to check for this + map = amf_result "/1" + assert map[0].empty? and map[1].empty? and map[2].empty? + end + end + + def test_whichways_deleted + node = current_nodes(:used_node_1) + minlon = node.lon-0.1 + minlat = node.lat-0.1 + maxlon = node.lon+0.1 + maxlat = node.lat+0.1 + amf_content "whichways_deleted", "/1", [minlon, minlat, maxlon, maxlat] + post :amf_read + assert_response :success + amf_parse_response + + # check contents of message + ways = amf_result "/1" + assert ways[0].include?(current_ways(:invisible_way).id) + assert !ways[0].include?(current_ways(:used_way).id) end + + def test_whichways_deleted_toobig + bbox = [-0.1,-0.1,1.1,1.1] + amf_content "whichways_deleted", "/1", bbox + post :amf_read + assert_response :success + amf_parse_response + + ways = amf_result "/1" + assert ways[0].empty? + end + + def test_getrelation + id = current_relations(:visible_relation).id + amf_content "getrelation", "/1", [id] + post :amf_read + assert_response :success + amf_parse_response + assert_equal amf_result("/1")[0], id + end + + def test_getrelation_invisible + id = current_relations(:invisible_relation).id + amf_content "getrelation", "/1", [id] + post :amf_read + assert_response :success + amf_parse_response + rel = amf_result("/1") + assert_equal rel[0], id + assert rel[1].empty? and rel[2].empty? + end + + def test_getrelation_nonexistent + id = 0 + amf_content "getrelation", "/1", [id] + post :amf_read + assert_response :success + amf_parse_response + rel = amf_result("/1") + assert_equal rel[0], id + assert rel[1].empty? and rel[2].empty? + end + + # Get the result record for the specified ID + # It's an assertion FAIL if the record does not exist + def amf_result ref + assert @amf_result.has_key?("#{ref}/onResult") + @amf_result["#{ref}/onResult"] + end + + # Encode the AMF message to invoke "target" with parameters as + # the passed data. The ref is used to retrieve the results. + def amf_content(target, ref, data) + a,b=1.divmod(256) + c = StringIO.new() + c.write 0.chr+0.chr # version 0 + c.write 0.chr+0.chr # n headers + c.write a.chr+b.chr # n bodies + c.write AMF.encodestring(target) + c.write AMF.encodestring(ref) + c.write [-1].pack("N") + c.write AMF.encodevalue(data) + + @request.env["RAW_POST_DATA"] = c.string + end + + # Parses the @response object as an AMF messsage. + # The result is a hash of message_ref => data. + # The attribute @amf_result is initialised to this hash. + def amf_parse_response + if @response.body.class.to_s == 'Proc' + res = StringIO.new() + @response.body.call @response, res + req = StringIO.new(res.string) + else + req = StringIO.new(@response.body) + end + req.read(2) # version + + # parse through any headers + headers=AMF.getint(req) # Read number of headers + headers.times do # Read each header + name=AMF.getstring(req) # | + req.getc # | skip boolean + value=AMF.getvalue(req) # | + end + + # parse through responses + results = {} + bodies=AMF.getint(req) # Read number of bodies + bodies.times do # Read each body + message=AMF.getstring(req) # | get message name + index=AMF.getstring(req) # | get index in response sequence + bytes=AMF.getlong(req) # | get total size in bytes + args=AMF.getvalue(req) # | get response (probably an array) + results[message] = args + end + @amf_result = results + results + end + end -- 2.43.2