Refactor some way_controller tests to use factories.
[rails.git] / test / controllers / way_controller_test.rb
1 require "test_helper"
2 require "way_controller"
3
4 class WayControllerTest < ActionController::TestCase
5   api_fixtures
6
7   ##
8   # test all routes which lead to this controller
9   def test_routes
10     assert_routing(
11       { :path => "/api/0.6/way/create", :method => :put },
12       { :controller => "way", :action => "create" }
13     )
14     assert_routing(
15       { :path => "/api/0.6/way/1/full", :method => :get },
16       { :controller => "way", :action => "full", :id => "1" }
17     )
18     assert_routing(
19       { :path => "/api/0.6/way/1", :method => :get },
20       { :controller => "way", :action => "read", :id => "1" }
21     )
22     assert_routing(
23       { :path => "/api/0.6/way/1", :method => :put },
24       { :controller => "way", :action => "update", :id => "1" }
25     )
26     assert_routing(
27       { :path => "/api/0.6/way/1", :method => :delete },
28       { :controller => "way", :action => "delete", :id => "1" }
29     )
30     assert_routing(
31       { :path => "/api/0.6/ways", :method => :get },
32       { :controller => "way", :action => "ways" }
33     )
34   end
35
36   # -------------------------------------
37   # Test reading ways.
38   # -------------------------------------
39
40   def test_read
41     # check that a visible way is returned properly
42     get :read, :id => current_ways(:visible_way).id
43     assert_response :success
44
45     # check that an invisible way is not returned
46     get :read, :id => current_ways(:invisible_way).id
47     assert_response :gone
48
49     # check chat a non-existent way is not returned
50     get :read, :id => 0
51     assert_response :not_found
52   end
53
54   ##
55   # check the "full" mode
56   def test_full
57     Way.all.each do |way|
58       get :full, :id => way.id
59
60       # full call should say "gone" for non-visible ways...
61       unless way.visible
62         assert_response :gone
63         next
64       end
65
66       # otherwise it should say success
67       assert_response :success
68
69       # Check the way is correctly returned
70       assert_select "osm way[id='#{way.id}'][version='#{way.version}'][visible='#{way.visible}']", 1
71
72       # check that each node in the way appears once in the output as a
73       # reference and as the node element.
74       way.nodes.each do |n|
75         count = (way.nodes - (way.nodes - [n])).length
76         assert_select "osm way nd[ref='#{n.id}']", count
77         assert_select "osm node[id='#{n.id}'][version='#{n.version}'][lat='#{format('%.7f', n.lat)}'][lon='#{format('%.7f', n.lon)}']", 1
78       end
79     end
80   end
81
82   ##
83   # test fetching multiple ways
84   def test_ways
85     # check error when no parameter provided
86     get :ways
87     assert_response :bad_request
88
89     # check error when no parameter value provided
90     get :ways, :ways => ""
91     assert_response :bad_request
92
93     # test a working call
94     get :ways, :ways => "1,2,4,6"
95     assert_response :success
96     assert_select "osm" do
97       assert_select "way", :count => 4
98       assert_select "way[id='1'][visible='true']", :count => 1
99       assert_select "way[id='2'][visible='false']", :count => 1
100       assert_select "way[id='4'][visible='true']", :count => 1
101       assert_select "way[id='6'][visible='true']", :count => 1
102     end
103
104     # check error when a non-existent way is included
105     get :ways, :ways => "1,2,4,6,400"
106     assert_response :not_found
107   end
108
109   # -------------------------------------
110   # Test simple way creation.
111   # -------------------------------------
112
113   def test_create
114     node1 = create(:node)
115     node2 = create(:node)
116     private_user = create(:user, :data_public => false)
117     private_changeset = create(:changeset, :user => private_user)
118     user = create(:user)
119     changeset = create(:changeset, :user => user)
120
121     ## First check that it fails when creating a way using a non-public user
122     basic_authorization private_user.email, "test"
123
124     # use the first user's open changeset
125     changeset_id = private_changeset.id
126
127     # create a way with pre-existing nodes
128     content "<osm><way changeset='#{changeset_id}'>" +
129             "<nd ref='#{node1.id}'/><nd ref='#{node2.id}'/>" +
130             "<tag k='test' v='yes' /></way></osm>"
131     put :create
132     # hope for failure
133     assert_response :forbidden,
134                     "way upload did not return forbidden status"
135
136     ## Now use a public user
137     basic_authorization user.email, "test"
138
139     # use the first user's open changeset
140     changeset_id = changeset.id
141
142     # create a way with pre-existing nodes
143     content "<osm><way changeset='#{changeset_id}'>" +
144             "<nd ref='#{node1.id}'/><nd ref='#{node2.id}'/>" +
145             "<tag k='test' v='yes' /></way></osm>"
146     put :create
147     # hope for success
148     assert_response :success,
149                     "way upload did not return success status"
150     # read id of created way and search for it
151     wayid = @response.body
152     checkway = Way.find(wayid)
153     assert_not_nil checkway,
154                    "uploaded way not found in data base after upload"
155     # compare values
156     assert_equal checkway.nds.length, 2,
157                  "saved way does not contain exactly one node"
158     assert_equal checkway.nds[0], node1.id,
159                  "saved way does not contain the right node on pos 0"
160     assert_equal checkway.nds[1], node2.id,
161                  "saved way does not contain the right node on pos 1"
162     assert_equal checkway.changeset_id, changeset_id,
163                  "saved way does not belong to the correct changeset"
164     assert_equal user.id, checkway.changeset.user_id,
165                  "saved way does not belong to user that created it"
166     assert_equal true, checkway.visible,
167                  "saved way is not visible"
168   end
169
170   # -------------------------------------
171   # Test creating some invalid ways.
172   # -------------------------------------
173
174   def test_create_invalid
175     node = create(:node)
176     private_user = create(:user, :data_public => false)
177     private_open_changeset = create(:changeset, :user => private_user)
178     private_closed_changeset = create(:changeset, :closed, :user => private_user)
179     user = create(:user)
180     open_changeset = create(:changeset, :user => user)
181     closed_changeset = create(:changeset, :closed, :user => user)
182
183     ## First test with a private user to make sure that they are not authorized
184     basic_authorization private_user.email, "test"
185
186     # use the first user's open changeset
187     # create a way with non-existing node
188     content "<osm><way changeset='#{private_open_changeset.id}'>" +
189             "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
190     put :create
191     # expect failure
192     assert_response :forbidden,
193                     "way upload with invalid node using a private user did not return 'forbidden'"
194
195     # create a way with no nodes
196     content "<osm><way changeset='#{private_open_changeset.id}'>" +
197             "<tag k='test' v='yes' /></way></osm>"
198     put :create
199     # expect failure
200     assert_response :forbidden,
201                     "way upload with no node using a private userdid not return 'forbidden'"
202
203     # create a way inside a closed changeset
204     content "<osm><way changeset='#{private_closed_changeset.id}'>" +
205             "<nd ref='#{node.id}'/></way></osm>"
206     put :create
207     # expect failure
208     assert_response :forbidden,
209                     "way upload to closed changeset with a private user did not return 'forbidden'"
210
211     ## Now test with a public user
212     basic_authorization user.email, "test"
213
214     # use the first user's open changeset
215     # create a way with non-existing node
216     content "<osm><way changeset='#{open_changeset.id}'>" +
217             "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
218     put :create
219     # expect failure
220     assert_response :precondition_failed,
221                     "way upload with invalid node did not return 'precondition failed'"
222     assert_equal "Precondition failed: Way  requires the nodes with id in (0), which either do not exist, or are not visible.", @response.body
223
224     # create a way with no nodes
225     content "<osm><way changeset='#{open_changeset.id}'>" +
226             "<tag k='test' v='yes' /></way></osm>"
227     put :create
228     # expect failure
229     assert_response :precondition_failed,
230                     "way upload with no node did not return 'precondition failed'"
231     assert_equal "Precondition failed: Cannot create way: data is invalid.", @response.body
232
233     # create a way inside a closed changeset
234     content "<osm><way changeset='#{closed_changeset.id}'>" +
235             "<nd ref='#{node.id}'/></way></osm>"
236     put :create
237     # expect failure
238     assert_response :conflict,
239                     "way upload to closed changeset did not return 'conflict'"
240
241     # create a way with a tag which is too long
242     content "<osm><way changeset='#{open_changeset.id}'>" +
243             "<nd ref='#{node.id}'/>" +
244             "<tag k='foo' v='#{'x' * 256}'/>" +
245             "</way></osm>"
246     put :create
247     # expect failure
248     assert_response :bad_request,
249                     "way upload to with too long tag did not return 'bad_request'"
250   end
251
252   # -------------------------------------
253   # Test deleting ways.
254   # -------------------------------------
255
256   def test_delete
257     # first try to delete way without auth
258     delete :delete, :id => current_ways(:visible_way).id
259     assert_response :unauthorized
260
261     # now set auth using the private user
262     basic_authorization(users(:normal_user).email, "test")
263
264     # this shouldn't work as with the 0.6 api we need pay load to delete
265     delete :delete, :id => current_ways(:visible_way).id
266     assert_response :forbidden
267
268     # Now try without having a changeset
269     content "<osm><way id='#{current_ways(:visible_way).id}'/></osm>"
270     delete :delete, :id => current_ways(:visible_way).id
271     assert_response :forbidden
272
273     # try to delete with an invalid (closed) changeset
274     content update_changeset(current_ways(:visible_way).to_xml,
275                              changesets(:normal_user_closed_change).id)
276     delete :delete, :id => current_ways(:visible_way).id
277     assert_response :forbidden
278
279     # try to delete with an invalid (non-existent) changeset
280     content update_changeset(current_ways(:visible_way).to_xml, 0)
281     delete :delete, :id => current_ways(:visible_way).id
282     assert_response :forbidden
283
284     # Now try with a valid changeset
285     content current_ways(:visible_way).to_xml
286     delete :delete, :id => current_ways(:visible_way).id
287     assert_response :forbidden
288
289     # check the returned value - should be the new version number
290     # valid delete should return the new version number, which should
291     # be greater than the old version number
292     # assert @response.body.to_i > current_ways(:visible_way).version,
293     #   "delete request should return a new version number for way"
294
295     # this won't work since the way is already deleted
296     content current_ways(:invisible_way).to_xml
297     delete :delete, :id => current_ways(:invisible_way).id
298     assert_response :forbidden
299
300     # this shouldn't work as the way is used in a relation
301     content current_ways(:used_way).to_xml
302     delete :delete, :id => current_ways(:used_way).id
303     assert_response :forbidden,
304                     "shouldn't be able to delete a way used in a relation (#{@response.body}), when done by a private user"
305
306     # this won't work since the way never existed
307     delete :delete, :id => 0
308     assert_response :forbidden
309
310     ### Now check with a public user
311     # now set auth
312     basic_authorization(users(:public_user).email, "test")
313
314     # this shouldn't work as with the 0.6 api we need pay load to delete
315     delete :delete, :id => current_ways(:visible_way).id
316     assert_response :bad_request
317
318     # Now try without having a changeset
319     content "<osm><way id='#{current_ways(:visible_way).id}'/></osm>"
320     delete :delete, :id => current_ways(:visible_way).id
321     assert_response :bad_request
322
323     # try to delete with an invalid (closed) changeset
324     content update_changeset(current_ways(:visible_way).to_xml,
325                              changesets(:public_user_closed_change).id)
326     delete :delete, :id => current_ways(:visible_way).id
327     assert_response :conflict
328
329     # try to delete with an invalid (non-existent) changeset
330     content update_changeset(current_ways(:visible_way).to_xml, 0)
331     delete :delete, :id => current_ways(:visible_way).id
332     assert_response :conflict
333
334     # Now try with a valid changeset
335     content current_ways(:visible_way).to_xml
336     delete :delete, :id => current_ways(:visible_way).id
337     assert_response :success
338
339     # check the returned value - should be the new version number
340     # valid delete should return the new version number, which should
341     # be greater than the old version number
342     assert @response.body.to_i > current_ways(:visible_way).version,
343            "delete request should return a new version number for way"
344
345     # this won't work since the way is already deleted
346     content current_ways(:invisible_way).to_xml
347     delete :delete, :id => current_ways(:invisible_way).id
348     assert_response :gone
349
350     # this shouldn't work as the way is used in a relation
351     content current_ways(:used_way).to_xml
352     delete :delete, :id => current_ways(:used_way).id
353     assert_response :precondition_failed,
354                     "shouldn't be able to delete a way used in a relation (#{@response.body})"
355     assert_equal "Precondition failed: Way 3 is still used by relations 1.", @response.body
356
357     # this won't work since the way never existed
358     delete :delete, :id => 0
359     assert_response :not_found
360   end
361
362   ##
363   # tests whether the API works and prevents incorrect use while trying
364   # to update ways.
365   def test_update
366     private_user = create(:user, :data_public => false)
367     private_way = create(:way, :changeset => create(:changeset, :user => private_user))
368     user = create(:user)
369     way = create(:way, :changeset => create(:changeset, :user => user))
370     node = create(:node)
371     create(:way_node, :way => private_way, :node => node)
372     create(:way_node, :way => way, :node => node)
373
374     ## First test with no user credentials
375     # try and update a way without authorisation
376     content way.to_xml
377     put :update, :id => way.id
378     assert_response :unauthorized
379
380     ## Second test with the private user
381
382     # setup auth
383     basic_authorization(private_user.email, "test")
384
385     ## trying to break changesets
386
387     # try and update in someone else's changeset
388     content update_changeset(private_way.to_xml,
389                              create(:changeset).id)
390     put :update, :id => private_way.id
391     assert_require_public_data "update with other user's changeset should be forbidden when date isn't public"
392
393     # try and update in a closed changeset
394     content update_changeset(private_way.to_xml,
395                              create(:changeset, :closed, :user => private_user))
396     put :update, :id => private_way.id
397     assert_require_public_data "update with closed changeset should be forbidden, when data isn't public"
398
399     # try and update in a non-existant changeset
400     content update_changeset(private_way.to_xml, 0)
401     put :update, :id => private_way.id
402     assert_require_public_data("update with changeset=0 should be forbidden, when data isn't public")
403
404     ## try and submit invalid updates
405     content xml_replace_node(private_way.to_xml, node.id, 9999)
406     put :update, :id => private_way.id
407     assert_require_public_data "way with non-existent node should be forbidden, when data isn't public"
408
409     content xml_replace_node(private_way.to_xml, node.id, create(:node, :deleted).id)
410     put :update, :id => private_way.id
411     assert_require_public_data "way with deleted node should be forbidden, when data isn't public"
412
413     ## finally, produce a good request which will still not work
414     content private_way.to_xml
415     put :update, :id => private_way.id
416     assert_require_public_data "should have failed with a forbidden when data isn't public"
417
418     ## Finally test with the public user
419
420     # setup auth
421     basic_authorization(user.email, "test")
422
423     ## trying to break changesets
424
425     # try and update in someone else's changeset
426     content update_changeset(way.to_xml,
427                              create(:changeset).id)
428     put :update, :id => way.id
429     assert_response :conflict, "update with other user's changeset should be rejected"
430
431     # try and update in a closed changeset
432     content update_changeset(way.to_xml,
433                              changesets(:normal_user_closed_change).id)
434     put :update, :id => way.id
435     assert_response :conflict, "update with closed changeset should be rejected"
436
437     # try and update in a non-existant changeset
438     content update_changeset(way.to_xml, 0)
439     put :update, :id => way.id
440     assert_response :conflict, "update with changeset=0 should be rejected"
441
442     ## try and submit invalid updates
443     content xml_replace_node(way.to_xml, node.id, 9999)
444     put :update, :id => way.id
445     assert_response :precondition_failed, "way with non-existent node should be rejected"
446
447     content xml_replace_node(way.to_xml, node.id, create(:node, :deleted).id)
448     put :update, :id => way.id
449     assert_response :precondition_failed, "way with deleted node should be rejected"
450
451     ## next, attack the versioning
452     current_way_version = way.version
453
454     # try and submit a version behind
455     content xml_attr_rewrite(way.to_xml,
456                              "version", current_way_version - 1)
457     put :update, :id => way.id
458     assert_response :conflict, "should have failed on old version number"
459
460     # try and submit a version ahead
461     content xml_attr_rewrite(way.to_xml,
462                              "version", current_way_version + 1)
463     put :update, :id => way.id
464     assert_response :conflict, "should have failed on skipped version number"
465
466     # try and submit total crap in the version field
467     content xml_attr_rewrite(way.to_xml,
468                              "version", "p1r4t3s!")
469     put :update, :id => way.id
470     assert_response :conflict,
471                     "should not be able to put 'p1r4at3s!' in the version field"
472
473     ## try an update with the wrong ID
474     content create(:way).to_xml
475     put :update, :id => way.id
476     assert_response :bad_request,
477                     "should not be able to update a way with a different ID from the XML"
478
479     ## try an update with a minimal valid XML doc which isn't a well-formed OSM doc.
480     content "<update/>"
481     put :update, :id => way.id
482     assert_response :bad_request,
483                     "should not be able to update a way with non-OSM XML doc."
484
485     ## finally, produce a good request which should work
486     content way.to_xml
487     put :update, :id => way.id
488     assert_response :success, "a valid update request failed"
489   end
490
491   # ------------------------------------------------------------
492   # test tags handling
493   # ------------------------------------------------------------
494
495   ##
496   # Try adding a new tag to a way
497   def test_add_tags
498     ## Try with the non-public user
499     # setup auth
500     basic_authorization(users(:normal_user).email, "test")
501
502     # add an identical tag to the way
503     tag_xml = XML::Node.new("tag")
504     tag_xml["k"] = "new"
505     tag_xml["v"] = "yes"
506
507     # add the tag into the existing xml
508     way_xml = current_ways(:visible_way).to_xml
509     way_xml.find("//osm/way").first << tag_xml
510
511     # try and upload it
512     content way_xml
513     put :update, :id => current_ways(:visible_way).id
514     assert_response :forbidden,
515                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
516
517     ## Now try with the public user
518     # setup auth
519     basic_authorization(users(:public_user).email, "test")
520
521     # add an identical tag to the way
522     tag_xml = XML::Node.new("tag")
523     tag_xml["k"] = "new"
524     tag_xml["v"] = "yes"
525
526     # add the tag into the existing xml
527     way_xml = current_ways(:visible_way).to_xml
528     way_xml.find("//osm/way").first << tag_xml
529
530     # try and upload it
531     content way_xml
532     put :update, :id => current_ways(:visible_way).id
533     assert_response :success,
534                     "adding a new tag to a way should succeed"
535     assert_equal current_ways(:visible_way).version + 1, @response.body.to_i
536   end
537
538   ##
539   # Try adding a duplicate of an existing tag to a way
540   def test_add_duplicate_tags
541     ## Try with the non-public user
542     # setup auth
543     basic_authorization(users(:normal_user).email, "test")
544
545     existing = create(:way_tag, :way => current_ways(:visible_way))
546
547     # add an identical tag to the way
548     tag_xml = XML::Node.new("tag")
549     tag_xml["k"] = existing.k
550     tag_xml["v"] = existing.v
551
552     # add the tag into the existing xml
553     way_xml = current_ways(:visible_way).to_xml
554     way_xml.find("//osm/way").first << tag_xml
555
556     # try and upload it
557     content way_xml
558     put :update, :id => current_ways(:visible_way).id
559     assert_response :forbidden,
560                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
561
562     ## Now try with the public user
563     # setup auth
564     basic_authorization(users(:public_user).email, "test")
565
566     # add an identical tag to the way
567     tag_xml = XML::Node.new("tag")
568     tag_xml["k"] = existing.k
569     tag_xml["v"] = existing.v
570
571     # add the tag into the existing xml
572     way_xml = current_ways(:visible_way).to_xml
573     way_xml.find("//osm/way").first << tag_xml
574
575     # try and upload it
576     content way_xml
577     put :update, :id => current_ways(:visible_way).id
578     assert_response :bad_request,
579                     "adding a duplicate tag to a way should fail with 'bad request'"
580     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{existing.k}", @response.body
581   end
582
583   ##
584   # Try adding a new duplicate tags to a way
585   def test_new_duplicate_tags
586     ## First test with the non-public user so should be rejected
587     # setup auth
588     basic_authorization(users(:normal_user).email, "test")
589
590     # create duplicate tag
591     tag_xml = XML::Node.new("tag")
592     tag_xml["k"] = "i_am_a_duplicate"
593     tag_xml["v"] = "foobar"
594
595     # add the tag into the existing xml
596     way_xml = current_ways(:visible_way).to_xml
597
598     # add two copies of the tag
599     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
600
601     # try and upload it
602     content way_xml
603     put :update, :id => current_ways(:visible_way).id
604     assert_response :forbidden,
605                     "adding new duplicate tags to a way using a non-public user should fail with 'forbidden'"
606
607     ## Now test with the public user
608     # setup auth
609     basic_authorization(users(:public_user).email, "test")
610
611     # create duplicate tag
612     tag_xml = XML::Node.new("tag")
613     tag_xml["k"] = "i_am_a_duplicate"
614     tag_xml["v"] = "foobar"
615
616     # add the tag into the existing xml
617     way_xml = current_ways(:visible_way).to_xml
618
619     # add two copies of the tag
620     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
621
622     # try and upload it
623     content way_xml
624     put :update, :id => current_ways(:visible_way).id
625     assert_response :bad_request,
626                     "adding new duplicate tags to a way should fail with 'bad request'"
627     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate", @response.body
628   end
629
630   ##
631   # Try adding a new duplicate tags to a way.
632   # But be a bit subtle - use unicode decoding ambiguities to use different
633   # binary strings which have the same decoding.
634   def test_invalid_duplicate_tags
635     ## First make sure that you can't with a non-public user
636     # setup auth
637     basic_authorization(users(:normal_user).email, "test")
638
639     # add the tag into the existing xml
640     way_str = "<osm><way changeset='1'>"
641     way_str << "<tag k='addr:housenumber' v='1'/>"
642     way_str << "<tag k='addr:housenumber' v='2'/>"
643     way_str << "</way></osm>"
644
645     # try and upload it
646     content way_str
647     put :create
648     assert_response :forbidden,
649                     "adding new duplicate tags to a way with a non-public user should fail with 'forbidden'"
650
651     ## Now do it with a public user
652     # setup auth
653     basic_authorization(users(:public_user).email, "test")
654
655     # add the tag into the existing xml
656     way_str = "<osm><way changeset='1'>"
657     way_str << "<tag k='addr:housenumber' v='1'/>"
658     way_str << "<tag k='addr:housenumber' v='2'/>"
659     way_str << "</way></osm>"
660
661     # try and upload it
662     content way_str
663     put :create
664     assert_response :bad_request,
665                     "adding new duplicate tags to a way should fail with 'bad request'"
666     assert_equal "Element way/ has duplicate tags with key addr:housenumber", @response.body
667   end
668
669   ##
670   # test that a call to ways_for_node returns all ways that contain the node
671   # and none that don't.
672   def test_ways_for_node
673     # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4
674     # *used* to use it but doesn't.
675     get :ways_for_node, :id => current_nodes(:used_node_1).id
676     assert_response :success
677     ways_xml = XML::Parser.string(@response.body).parse
678     assert_not_nil ways_xml, "failed to parse ways_for_node response"
679
680     # check that the set of IDs match expectations
681     expected_way_ids = [current_ways(:visible_way).id,
682                         current_ways(:used_way).id]
683     found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
684     assert_equal expected_way_ids.sort, found_way_ids.sort,
685                  "expected ways for node #{current_nodes(:used_node_1).id} did not match found"
686
687     # check the full ways to ensure we're not missing anything
688     expected_way_ids.each do |id|
689       way_xml = ways_xml.find("//osm/way[@id='#{id}']").first
690       assert_ways_are_equal(Way.find(id),
691                             Way.from_xml_node(way_xml))
692     end
693   end
694
695   ##
696   # update the changeset_id of a way element
697   def update_changeset(xml, changeset_id)
698     xml_attr_rewrite(xml, "changeset", changeset_id)
699   end
700
701   ##
702   # update an attribute in the way element
703   def xml_attr_rewrite(xml, name, value)
704     xml.find("//osm/way").first[name] = value.to_s
705     xml
706   end
707
708   ##
709   # replace a node in a way element
710   def xml_replace_node(xml, old_node, new_node)
711     xml.find("//osm/way/nd[@ref='#{old_node}']").first["ref"] = new_node.to_s
712     xml
713   end
714 end