test/models/way_test.rb

   1 require "test_helper"
   2
   3 class WayTest < ActiveSupport::TestCase
   4   api_fixtures
   5
   6   # Check that we have the correct number of currnet ways in the db
   7   # This will need to updated whenever the current_ways.yml is updated
   8   def test_db_count
   9     assert_equal 7, Way.count
  10   end
  11
  12   def test_bbox
  13     node = create(:node)
  14     visible_way = create(:way)
  15     create(:way_node, :way => visible_way, :node => node)
  16     invisible_way = create(:way, :deleted)
  17     create(:way_node, :way => invisible_way, :node => node)
  18     used_way = create(:way)
  19     create(:way_node, :way => used_way, :node => node)
  20     create(:relation_member, :member => used_way)
  21
  22     [visible_way, invisible_way, used_way].each do |way|
  23       assert_equal node.bbox.min_lon, way.bbox.min_lon, "min_lon"
  24       assert_equal node.bbox.min_lat, way.bbox.min_lat, "min_lat"
  25       assert_equal node.bbox.max_lon, way.bbox.max_lon, "max_lon"
  26       assert_equal node.bbox.max_lat, way.bbox.max_lat, "max_lat"
  27     end
  28   end
  29
  30   # Check that the preconditions fail when you are over the defined limit of
  31   # the maximum number of nodes in each way.
  32   def test_max_nodes_per_way_limit
  33     node_a = create(:node)
  34     node_b = create(:node)
  35     node_c = create(:node)
  36     way = create(:way_with_nodes, :nodes_count => 1)
  37     # Take one of the current ways and add nodes to it until we are near the limit
  38     assert way.valid?
  39     # it already has 1 node
  40     1.upto(MAX_NUMBER_OF_WAY_NODES / 2) do
  41       way.add_nd_num(node_a.id)
  42       way.add_nd_num(node_b.id)
  43     end
  44     way.save
  45     # print way.nds.size
  46     assert way.valid?
  47     way.add_nd_num(node_c.id)
  48     assert way.valid?
  49   end
  50
  51   def test_from_xml_no_id
  52     noid = "<osm><way version='12' changeset='23' /></osm>"
  53     assert_nothing_raised(OSM::APIBadXMLError) do
  54       Way.from_xml(noid, true)
  55     end
  56     message = assert_raise(OSM::APIBadXMLError) do
  57       Way.from_xml(noid, false)
  58     end
  59     assert_match /ID is required when updating/, message.message
  60   end
  61
  62   def test_from_xml_no_changeset_id
  63     nocs = "<osm><way id='123' version='23' /></osm>"
  64     message_create = assert_raise(OSM::APIBadXMLError) do
  65       Way.from_xml(nocs, true)
  66     end
  67     assert_match /Changeset id is missing/, message_create.message
  68     message_update = assert_raise(OSM::APIBadXMLError) do
  69       Way.from_xml(nocs, false)
  70     end
  71     assert_match /Changeset id is missing/, message_update.message
  72   end
  73
  74   def test_from_xml_no_version
  75     no_version = "<osm><way id='123' changeset='23' /></osm>"
  76     assert_nothing_raised(OSM::APIBadXMLError) do
  77       Way.from_xml(no_version, true)
  78     end
  79     message_update = assert_raise(OSM::APIBadXMLError) do
  80       Way.from_xml(no_version, false)
  81     end
  82     assert_match /Version is required when updating/, message_update.message
  83   end
  84
  85   def test_from_xml_id_zero
  86     id_list = ["", "0", "00", "0.0", "a"]
  87     id_list.each do |id|
  88       zero_id = "<osm><way id='#{id}' changeset='33' version='23' /></osm>"
  89       assert_nothing_raised(OSM::APIBadUserInput) do
  90         Way.from_xml(zero_id, true)
  91       end
  92       message_update = assert_raise(OSM::APIBadUserInput) do
  93         Way.from_xml(zero_id, false)
  94       end
  95       assert_match /ID of way cannot be zero when updating/, message_update.message
  96     end
  97   end
  98
  99   def test_from_xml_no_text
 100     no_text = ""
 101     message_create = assert_raise(OSM::APIBadXMLError) do
 102       Way.from_xml(no_text, true)
 103     end
 104     assert_match /Must specify a string with one or more characters/, message_create.message
 105     message_update = assert_raise(OSM::APIBadXMLError) do
 106       Way.from_xml(no_text, false)
 107     end
 108     assert_match /Must specify a string with one or more characters/, message_update.message
 109   end
 110
 111   def test_from_xml_no_k_v
 112     nokv = "<osm><way id='23' changeset='23' version='23'><tag /></way></osm>"
 113     message_create = assert_raise(OSM::APIBadXMLError) do
 114       Way.from_xml(nokv, true)
 115     end
 116     assert_match /tag is missing key/, message_create.message
 117     message_update = assert_raise(OSM::APIBadXMLError) do
 118       Way.from_xml(nokv, false)
 119     end
 120     assert_match /tag is missing key/, message_update.message
 121   end
 122
 123   def test_from_xml_no_v
 124     no_v = "<osm><way id='23' changeset='23' version='23'><tag k='key' /></way></osm>"
 125     message_create = assert_raise(OSM::APIBadXMLError) do
 126       Way.from_xml(no_v, true)
 127     end
 128     assert_match /tag is missing value/, message_create.message
 129     message_update = assert_raise(OSM::APIBadXMLError) do
 130       Way.from_xml(no_v, false)
 131     end
 132     assert_match /tag is missing value/, message_update.message
 133   end
 134
 135   def test_from_xml_duplicate_k
 136     dupk = "<osm><way id='23' changeset='23' version='23'><tag k='dup' v='test' /><tag k='dup' v='tester' /></way></osm>"
 137     message_create = assert_raise(OSM::APIDuplicateTagsError) do
 138       Way.from_xml(dupk, true)
 139     end
 140     assert_equal "Element way/ has duplicate tags with key dup", message_create.message
 141     message_update = assert_raise(OSM::APIDuplicateTagsError) do
 142       Way.from_xml(dupk, false)
 143     end
 144     assert_equal "Element way/23 has duplicate tags with key dup", message_update.message
 145   end
 146
 147   def test_way_nodes
 148     way = create(:way)
 149     node1 = create(:way_node, :way => way, :sequence_id => 1).node
 150     node2 = create(:way_node, :way => way, :sequence_id => 2).node
 151     node3 = create(:way_node, :way => way, :sequence_id => 3).node
 152
 153     nodes = Way.find(way.id).way_nodes
 154     assert_equal 3, nodes.count
 155     assert_equal node1.id, nodes[0].node_id
 156     assert_equal node2.id, nodes[1].node_id
 157     assert_equal node3.id, nodes[2].node_id
 158   end
 159
 160   def test_nodes
 161     way = create(:way)
 162     node1 = create(:way_node, :way => way, :sequence_id => 1).node
 163     node2 = create(:way_node, :way => way, :sequence_id => 2).node
 164     node3 = create(:way_node, :way => way, :sequence_id => 3).node
 165
 166     nodes = Way.find(way.id).nodes
 167     assert_equal 3, nodes.count
 168     assert_equal node1.id, nodes[0].id
 169     assert_equal node2.id, nodes[1].id
 170     assert_equal node3.id, nodes[2].id
 171   end
 172
 173   def test_nds
 174     way = create(:way)
 175     node1 = create(:way_node, :way => way, :sequence_id => 1).node
 176     node2 = create(:way_node, :way => way, :sequence_id => 2).node
 177     node3 = create(:way_node, :way => way, :sequence_id => 3).node
 178
 179     nodes = Way.find(way.id).nds
 180     assert_equal 3, nodes.count
 181     assert_equal node1.id, nodes[0]
 182     assert_equal node2.id, nodes[1]
 183     assert_equal node3.id, nodes[2]
 184   end
 185
 186   def test_way_tags
 187     way = create(:way)
 188     taglist = create_list(:way_tag, 2, :way => way)
 189     tags = Way.find(way.id).way_tags.order(:k)
 190     assert_equal taglist.count, tags.count
 191     taglist.sort_by!(&:k).each_index do |i|
 192       assert_equal taglist[i].k, tags[i].k
 193       assert_equal taglist[i].v, tags[i].v
 194     end
 195   end
 196
 197   def test_tags
 198     way = create(:way)
 199     taglist = create_list(:way_tag, 2, :way => way)
 200     tags = Way.find(way.id).tags
 201     assert_equal taglist.count, tags.count
 202     taglist.each do |tag|
 203       assert_equal tag.v, tags[tag.k]
 204     end
 205   end
 206
 207   def test_containing_relation_members
 208     way = create(:way)
 209     relation = create(:relation)
 210     create(:relation_member, :relation => relation, :member => way)
 211
 212     crm = Way.find(way.id).containing_relation_members.order(:relation_id)
 213     #    assert_equal 1, crm.size
 214     assert_equal relation.id, crm.first.relation_id
 215     assert_equal "Way", crm.first.member_type
 216     assert_equal way.id, crm.first.member_id
 217     assert_equal relation.id, crm.first.relation.id
 218   end
 219
 220   def test_containing_relations
 221     way = create(:way)
 222     relation = create(:relation)
 223     create(:relation_member, :relation => relation, :member => way)
 224
 225     cr = Way.find(way.id).containing_relations.order(:id)
 226     assert_equal 1, cr.size
 227     assert_equal relation.id, cr.first.id
 228   end
 229 end