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, :lat => 12.6543, :lon => 65.1234)
 102     create(:old_node, :node_id => node.id, :version => 1, :lat => node.lat, :lon => node.lon)
 103
 104     node_template = Node.find(node.id)
 105
 106     assert_not_nil node_template
 107     assert_equal(1, OldNode.where(:node_id => node_template.id).count)
 108     assert_not_nil node
 109
 110     node_template.lat = 12.3456
 111     node_template.lon = 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(2, OldNode.where(:node_id => node_template.id).count)
 124     old_node = OldNode.find_by(:node_id => node_template.id, :version => 2)
 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(1, OldNode.where(:node_id => node_template.id).count)
 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_not node.visible
 150     # assert_equal node_template.tags, node.tags
 151
 152     assert_equal(2, OldNode.where(:node_id => node_template.id).count)
 153     old_node = OldNode.find_by(:node_id => node_template.id, :version => 2)
 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_not 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 do
 170       Node.from_xml(noid, :create => 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, :create => 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, :create => true)
 183     end
 184     assert_match(/lat missing/, message_create.message)
 185     message_update = assert_raise(OSM::APIBadXMLError) do
 186       Node.from_xml(nolat, :create => 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, :create => true)
 195     end
 196     assert_match(/lon missing/, message_create.message)
 197     message_update = assert_raise(OSM::APIBadXMLError) do
 198       Node.from_xml(nolon, :create => 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, :create => 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, :create => 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 do
 218       Node.from_xml(no_version, :create => true)
 219     end
 220     message_update = assert_raise(OSM::APIBadXMLError) do
 221       Node.from_xml(no_version, :create => 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, :create => 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, :create => 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 do
 243         Node.from_xml(zero_id, :create => true)
 244       end
 245       message_update = assert_raise(OSM::APIBadUserInput) do
 246         Node.from_xml(zero_id, :create => 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, :create => 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, :create => 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, :create => 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, :create => 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, :create => 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, :create => 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, :create => 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, :create => 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, :create => 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, :create => 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
 367   test "raises missing changeset exception when creating" do
 368     user = create(:user)
 369     node = Node.new
 370     assert_raises OSM::APIChangesetMissingError do
 371       node.create_with_history(user)
 372     end
 373   end
 374
 375   test "raises user-changeset mismatch exception when creating" do
 376     user = create(:user)
 377     changeset = create(:changeset)
 378     node = Node.new(:changeset => changeset)
 379     assert_raises OSM::APIUserChangesetMismatchError do
 380       node.create_with_history(user)
 381     end
 382   end
 383
 384   test "raises already closed changeset exception when creating" do
 385     user = create(:user)
 386     changeset = create(:changeset, :closed, :user => user)
 387     node = Node.new(:changeset => changeset)
 388     assert_raises OSM::APIChangesetAlreadyClosedError do
 389       node.create_with_history(user)
 390     end
 391   end
 392
 393   test "raises id precondition exception when updating" do
 394     user = create(:user)
 395     node = Node.new(:id => 23)
 396     new_node = Node.new(:id => 42)
 397     assert_raises OSM::APIPreconditionFailedError do
 398       node.update_from(new_node, user)
 399     end
 400   end
 401
 402   test "raises version mismatch exception when updating" do
 403     user = create(:user)
 404     node = Node.new(:id => 42, :version => 7)
 405     new_node = Node.new(:id => 42, :version => 12)
 406     assert_raises OSM::APIVersionMismatchError do
 407       node.update_from(new_node, user)
 408     end
 409   end
 410
 411   test "raises missing changeset exception when updating" do
 412     user = create(:user)
 413     node = Node.new(:id => 42, :version => 12)
 414     new_node = Node.new(:id => 42, :version => 12)
 415     assert_raises OSM::APIChangesetMissingError do
 416       node.update_from(new_node, user)
 417     end
 418   end
 419
 420   test "raises user-changeset mismatch exception when updating" do
 421     user = create(:user)
 422     changeset = create(:changeset)
 423     node = Node.new(:id => 42, :version => 12)
 424     new_node = Node.new(:id => 42, :version => 12, :changeset => changeset)
 425     assert_raises OSM::APIUserChangesetMismatchError do
 426       node.update_from(new_node, user)
 427     end
 428   end
 429
 430   test "raises already closed changeset exception when updating" do
 431     user = create(:user)
 432     changeset = create(:changeset, :closed, :user => user)
 433     node = Node.new(:id => 42, :version => 12)
 434     new_node = Node.new(:id => 42, :version => 12, :changeset => changeset)
 435     assert_raises OSM::APIChangesetAlreadyClosedError do
 436       node.update_from(new_node, user)
 437     end
 438   end
 439
 440   test "raises id precondition exception when deleting" do
 441     user = create(:user)
 442     node = Node.new(:id => 23, :visible => true)
 443     new_node = Node.new(:id => 42, :visible => false)
 444     assert_raises OSM::APIPreconditionFailedError do
 445       node.delete_with_history!(new_node, user)
 446     end
 447   end
 448 end