test/models/node_test.rb

   1 require "test_helper"
   2
   3 class NodeTest < ActiveSupport::TestCase
   4   def test_node_too_far_north
   5     node = build(:node, :latitude => 90.01 * OldNode::SCALE)
   6     assert_equal false, node.valid?
   7   end
   8
   9   def test_node_north_limit
  10     node = build(:node, :latitude => 90 * OldNode::SCALE)
  11     assert node.valid?
  12   end
  13
  14   def test_node_too_far_south
  15     node = build(:node, :latitude => -90.01 * OldNode::SCALE)
  16     assert_equal false, node.valid?
  17   end
  18
  19   def test_node_south_limit
  20     node = build(:node, :latitude => -90 * OldNode::SCALE)
  21     assert node.valid?
  22   end
  23
  24   def test_node_too_far_west
  25     node = build(:node, :longitude => -180.01 * OldNode::SCALE)
  26     assert_equal false, node.valid?
  27   end
  28
  29   def test_node_west_limit
  30     node = build(:node, :longitude => -180 * OldNode::SCALE)
  31     assert node.valid?
  32   end
  33
  34   def test_node_too_far_east
  35     node = build(:node, :longitude => 180.01 * OldNode::SCALE)
  36     assert_equal false, node.valid?
  37   end
  38
  39   def test_node_east_limit
  40     node = build(:node, :longitude => 180 * OldNode::SCALE)
  41     assert node.valid?
  42   end
  43
  44   def test_totally_wrong
  45     node = build(:node, :latitude => 200 * OldNode::SCALE, :longitude => 200 * OldNode::SCALE)
  46     assert_equal false, node.valid?
  47   end
  48
  49   def test_lat_lon
  50     node = build(:node, :latitude => 12.345 * OldNode::SCALE, :longitude => 34.567 * OldNode::SCALE)
  51
  52     assert_in_delta 12.345, node.lat, 0.0000001
  53     assert_in_delta 34.567, node.lon, 0.0000001
  54
  55     node.lat = 54.321
  56     node.lon = 76.543
  57
  58     assert_in_delta 54.321 * OldNode::SCALE, node.latitude, 0.000001
  59     assert_in_delta 76.543 * OldNode::SCALE, node.longitude, 0.000001
  60   end
  61
  62   # Ensure the lat/lon is formatted as a decimal e.g. not 4.0e-05
  63   def test_lat_lon_xml_format
  64     node = build(:node, :latitude => 0.00004 * OldNode::SCALE, :longitude => 0.00008 * OldNode::SCALE)
  65
  66     assert_match /lat="0.0000400"/, node.to_xml.to_s
  67     assert_match /lon="0.0000800"/, node.to_xml.to_s
  68   end
  69
  70   # Check that you can create a node and store it
  71   def test_create
  72     changeset = create(:changeset)
  73     node_template = Node.new(
  74       :latitude => 12.3456,
  75       :longitude => 65.4321,
  76       :changeset_id => changeset.id,
  77       :visible => 1,
  78       :version => 1
  79     )
  80     assert node_template.create_with_history(changeset.user)
  81
  82     node = Node.find(node_template.id)
  83     assert_not_nil node
  84     assert_equal node_template.latitude, node.latitude
  85     assert_equal node_template.longitude, node.longitude
  86     assert_equal node_template.changeset_id, node.changeset_id
  87     assert_equal node_template.visible, node.visible
  88     assert_equal node_template.timestamp.to_i, node.timestamp.to_i
  89
  90     assert_equal OldNode.where(:node_id => node_template.id).count, 1
  91     old_node = OldNode.where(:node_id => node_template.id).first
  92     assert_not_nil old_node
  93     assert_equal node_template.latitude, old_node.latitude
  94     assert_equal node_template.longitude, old_node.longitude
  95     assert_equal node_template.changeset_id, old_node.changeset_id
  96     assert_equal node_template.visible, old_node.visible
  97     assert_equal node_template.tags, old_node.tags
  98     assert_equal node_template.timestamp.to_i, old_node.timestamp.to_i
  99   end
 100
 101   def test_update
 102     node = create(:node)
 103     create(:old_node, :node_id => node.id, :version => 1)
 104     node_template = Node.find(node.id)
 105
 106     assert_not_nil node_template
 107     assert_equal OldNode.where(:node_id => node_template.id).count, 1
 108     assert_not_nil node
 109
 110     node_template.latitude = 12.3456
 111     node_template.longitude = 65.4321
 112     # node_template.tags = "updated=yes"
 113     assert node.update_from(node_template, node.changeset.user)
 114
 115     node = Node.find(node_template.id)
 116     assert_not_nil node
 117     assert_equal node_template.latitude, node.latitude
 118     assert_equal node_template.longitude, node.longitude
 119     assert_equal node_template.changeset_id, node.changeset_id
 120     assert_equal node_template.visible, node.visible
 121     # assert_equal node_template.tags, node.tags
 122
 123     assert_equal OldNode.where(:node_id => node_template.id).count, 2
 124     old_node = OldNode.where(:node_id => node_template.id, :version => 2).first
 125     assert_not_nil old_node
 126     assert_equal node_template.latitude, old_node.latitude
 127     assert_equal node_template.longitude, old_node.longitude
 128     assert_equal node_template.changeset_id, old_node.changeset_id
 129     assert_equal node_template.visible, old_node.visible
 130     # assert_equal node_template.tags, old_node.tags
 131   end
 132
 133   def test_delete
 134     node = create(:node)
 135     create(:old_node, :node_id => node.id, :version => 1)
 136     node_template = Node.find(node.id)
 137
 138     assert_not_nil node_template
 139     assert_equal OldNode.where(:node_id => node_template.id).count, 1
 140     assert_not_nil node
 141
 142     assert node.delete_with_history!(node_template, node.changeset.user)
 143
 144     node = Node.find(node_template.id)
 145     assert_not_nil node
 146     assert_equal node_template.latitude, node.latitude
 147     assert_equal node_template.longitude, node.longitude
 148     assert_equal node_template.changeset_id, node.changeset_id
 149     assert_equal false, node.visible
 150     # assert_equal node_template.tags, node.tags
 151
 152     assert_equal OldNode.where(:node_id => node_template.id).count, 2
 153     old_node = OldNode.where(:node_id => node_template.id, :version => 2).first
 154     assert_not_nil old_node
 155     assert_equal node_template.latitude, old_node.latitude
 156     assert_equal node_template.longitude, old_node.longitude
 157     assert_equal node_template.changeset_id, old_node.changeset_id
 158     assert_equal false, old_node.visible
 159     # assert_equal node_template.tags, old_node.tags
 160   end
 161
 162   def test_from_xml_no_id
 163     lat = 56.7
 164     lon = -2.3
 165     changeset = 2
 166     version = 1
 167     noid = "<osm><node lat='#{lat}' lon='#{lon}' changeset='#{changeset}' version='#{version}' /></osm>"
 168     # First try a create which doesn't need the id
 169     assert_nothing_raised(OSM::APIBadXMLError) do
 170       Node.from_xml(noid, true)
 171     end
 172     # Now try an update with no id, and make sure that it gives the appropriate exception
 173     message = assert_raise(OSM::APIBadXMLError) do
 174       Node.from_xml(noid, false)
 175     end
 176     assert_match /ID is required when updating./, message.message
 177   end
 178
 179   def test_from_xml_no_lat
 180     nolat = "<osm><node id='1' lon='23.3' changeset='2' version='23' /></osm>"
 181     message_create = assert_raise(OSM::APIBadXMLError) do
 182       Node.from_xml(nolat, true)
 183     end
 184     assert_match /lat missing/, message_create.message
 185     message_update = assert_raise(OSM::APIBadXMLError) do
 186       Node.from_xml(nolat, false)
 187     end
 188     assert_match /lat missing/, message_update.message
 189   end
 190
 191   def test_from_xml_no_lon
 192     nolon = "<osm><node id='1' lat='23.1' changeset='2' version='23' /></osm>"
 193     message_create = assert_raise(OSM::APIBadXMLError) do
 194       Node.from_xml(nolon, true)
 195     end
 196     assert_match /lon missing/, message_create.message
 197     message_update = assert_raise(OSM::APIBadXMLError) do
 198       Node.from_xml(nolon, false)
 199     end
 200     assert_match /lon missing/, message_update.message
 201   end
 202
 203   def test_from_xml_no_changeset_id
 204     nocs = "<osm><node id='123' lon='23.23' lat='23.1' version='23' /></osm>"
 205     message_create = assert_raise(OSM::APIBadXMLError) do
 206       Node.from_xml(nocs, true)
 207     end
 208     assert_match /Changeset id is missing/, message_create.message
 209     message_update = assert_raise(OSM::APIBadXMLError) do
 210       Node.from_xml(nocs, false)
 211     end
 212     assert_match /Changeset id is missing/, message_update.message
 213   end
 214
 215   def test_from_xml_no_version
 216     no_version = "<osm><node id='123' lat='23' lon='23' changeset='23' /></osm>"
 217     assert_nothing_raised(OSM::APIBadXMLError) do
 218       Node.from_xml(no_version, true)
 219     end
 220     message_update = assert_raise(OSM::APIBadXMLError) do
 221       Node.from_xml(no_version, false)
 222     end
 223     assert_match /Version is required when updating/, message_update.message
 224   end
 225
 226   def test_from_xml_double_lat
 227     nocs = "<osm><node id='123' lon='23.23' lat='23.1' lat='12' changeset='23' version='23' /></osm>"
 228     message_create = assert_raise(OSM::APIBadXMLError) do
 229       Node.from_xml(nocs, true)
 230     end
 231     assert_match /Fatal error: Attribute lat redefined at/, message_create.message
 232     message_update = assert_raise(OSM::APIBadXMLError) do
 233       Node.from_xml(nocs, false)
 234     end
 235     assert_match /Fatal error: Attribute lat redefined at/, message_update.message
 236   end
 237
 238   def test_from_xml_id_zero
 239     id_list = ["", "0", "00", "0.0", "a"]
 240     id_list.each do |id|
 241       zero_id = "<osm><node id='#{id}' lat='12.3' lon='12.3' changeset='33' version='23' /></osm>"
 242       assert_nothing_raised(OSM::APIBadUserInput) do
 243         Node.from_xml(zero_id, true)
 244       end
 245       message_update = assert_raise(OSM::APIBadUserInput) do
 246         Node.from_xml(zero_id, false)
 247       end
 248       assert_match /ID of node cannot be zero when updating/, message_update.message
 249     end
 250   end
 251
 252   def test_from_xml_no_text
 253     no_text = ""
 254     message_create = assert_raise(OSM::APIBadXMLError) do
 255       Node.from_xml(no_text, true)
 256     end
 257     assert_match /Must specify a string with one or more characters/, message_create.message
 258     message_update = assert_raise(OSM::APIBadXMLError) do
 259       Node.from_xml(no_text, false)
 260     end
 261     assert_match /Must specify a string with one or more characters/, message_update.message
 262   end
 263
 264   def test_from_xml_no_node
 265     no_node = "<osm></osm>"
 266     message_create = assert_raise(OSM::APIBadXMLError) do
 267       Node.from_xml(no_node, true)
 268     end
 269     assert_match %r{XML doesn't contain an osm/node element}, message_create.message
 270     message_update = assert_raise(OSM::APIBadXMLError) do
 271       Node.from_xml(no_node, false)
 272     end
 273     assert_match %r{XML doesn't contain an osm/node element}, message_update.message
 274   end
 275
 276   def test_from_xml_no_k_v
 277     nokv = "<osm><node id='23' lat='12.3' lon='23.4' changeset='12' version='23'><tag /></node></osm>"
 278     message_create = assert_raise(OSM::APIBadXMLError) do
 279       Node.from_xml(nokv, true)
 280     end
 281     assert_match /tag is missing key/, message_create.message
 282     message_update = assert_raise(OSM::APIBadXMLError) do
 283       Node.from_xml(nokv, false)
 284     end
 285     assert_match /tag is missing key/, message_update.message
 286   end
 287
 288   def test_from_xml_no_v
 289     no_v = "<osm><node id='23' lat='23.43' lon='23.32' changeset='23' version='32'><tag k='key' /></node></osm>"
 290     message_create = assert_raise(OSM::APIBadXMLError) do
 291       Node.from_xml(no_v, true)
 292     end
 293     assert_match /tag is missing value/, message_create.message
 294     message_update = assert_raise(OSM::APIBadXMLError) do
 295       Node.from_xml(no_v, false)
 296     end
 297     assert_match /tag is missing value/, message_update.message
 298   end
 299
 300   def test_from_xml_duplicate_k
 301     dupk = "<osm><node id='23' lat='23.2' lon='23' changeset='34' version='23'><tag k='dup' v='test' /><tag k='dup' v='tester' /></node></osm>"
 302     message_create = assert_raise(OSM::APIDuplicateTagsError) do
 303       Node.from_xml(dupk, true)
 304     end
 305     assert_equal "Element node/ has duplicate tags with key dup", message_create.message
 306     message_update = assert_raise(OSM::APIDuplicateTagsError) do
 307       Node.from_xml(dupk, false)
 308     end
 309     assert_equal "Element node/23 has duplicate tags with key dup", message_update.message
 310   end
 311
 312   def test_node_tags
 313     node = create(:node)
 314     taglist = create_list(:node_tag, 2, :node => node)
 315     tags = Node.find(node.id).node_tags.order(:k)
 316     assert_equal taglist.count, tags.count
 317     taglist.sort_by!(&:k).each_index do |i|
 318       assert_equal taglist[i].k, tags[i].k
 319       assert_equal taglist[i].v, tags[i].v
 320     end
 321   end
 322
 323   def test_tags
 324     node = create(:node)
 325     taglist = create_list(:node_tag, 2, :node => node)
 326     tags = Node.find(node.id).tags
 327     assert_equal taglist.count, tags.count
 328     taglist.each do |tag|
 329       assert_equal tag.v, tags[tag.k]
 330     end
 331   end
 332
 333   def test_containing_relation_members
 334     node = create(:node)
 335     relation_member1 = create(:relation_member, :member => node)
 336     relation_member2 = create(:relation_member, :member => node)
 337     relation_member3 = create(:relation_member, :member => node)
 338     crm = Node.find(node.id).containing_relation_members.order(:relation_id)
 339     #    assert_equal 3, crm.size
 340     assert_equal relation_member1.relation_id, crm.first.relation_id
 341     assert_equal "Node", crm.first.member_type
 342     assert_equal node.id, crm.first.member_id
 343     assert_equal relation_member1.relation_id, crm.first.relation.id
 344     assert_equal relation_member2.relation_id, crm.second.relation_id
 345     assert_equal "Node", crm.second.member_type
 346     assert_equal node.id, crm.second.member_id
 347     assert_equal relation_member2.relation_id, crm.second.relation.id
 348     assert_equal relation_member3.relation_id, crm.third.relation_id
 349     assert_equal "Node", crm.third.member_type
 350     assert_equal node.id, crm.third.member_id
 351     assert_equal relation_member3.relation_id, crm.third.relation.id
 352   end
 353
 354   def test_containing_relations
 355     node = create(:node)
 356     relation_member1 = create(:relation_member, :member => node)
 357     relation_member2 = create(:relation_member, :member => node)
 358     relation_member3 = create(:relation_member, :member => node)
 359     cr = Node.find(node.id).containing_relations.order(:id)
 360
 361     assert_equal 3, cr.size
 362     assert_equal relation_member1.relation.id, cr.first.id
 363     assert_equal relation_member2.relation.id, cr.second.id
 364     assert_equal relation_member3.relation.id, cr.third.id
 365   end
 366 end