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