]> git.openstreetmap.org Git - rails.git/blob - test/controllers/way_controller_test.rb
7813fb029f772e05fb97f9f416d18c62c8234fc9
[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     private_user = create(:user, :data_public => false)
258     private_open_changeset = create(:changeset, :user => private_user)
259     private_closed_changeset = create(:changeset, :closed, :user => private_user)
260     private_way = create(:way, :changeset => private_open_changeset)
261     private_deleted_way = create(:way, :deleted, :changeset => private_open_changeset)
262     private_used_way = create(:way, :changeset => private_open_changeset)
263     create(:relation_member, :member => private_used_way)
264     user = create(:user)
265     open_changeset = create(:changeset, :user => user)
266     closed_changeset = create(:changeset, :closed, :user => user)
267     way = create(:way, :changeset => open_changeset)
268     deleted_way = create(:way, :deleted, :changeset => open_changeset)
269     used_way = create(:way, :changeset => open_changeset)
270     relation_member = create(:relation_member, :member => used_way)
271     relation = relation_member.relation
272
273     # first try to delete way without auth
274     delete :delete, :id => way.id
275     assert_response :unauthorized
276
277     # now set auth using the private user
278     basic_authorization(private_user.email, "test")
279
280     # this shouldn't work as with the 0.6 api we need pay load to delete
281     delete :delete, :id => private_way.id
282     assert_response :forbidden
283
284     # Now try without having a changeset
285     content "<osm><way id='#{private_way.id}'/></osm>"
286     delete :delete, :id => private_way.id
287     assert_response :forbidden
288
289     # try to delete with an invalid (closed) changeset
290     content update_changeset(private_way.to_xml, private_closed_changeset.id)
291     delete :delete, :id => private_way.id
292     assert_response :forbidden
293
294     # try to delete with an invalid (non-existent) changeset
295     content update_changeset(private_way.to_xml, 0)
296     delete :delete, :id => private_way.id
297     assert_response :forbidden
298
299     # Now try with a valid changeset
300     content private_way.to_xml
301     delete :delete, :id => private_way.id
302     assert_response :forbidden
303
304     # check the returned value - should be the new version number
305     # valid delete should return the new version number, which should
306     # be greater than the old version number
307     # assert @response.body.to_i > current_ways(:visible_way).version,
308     #   "delete request should return a new version number for way"
309
310     # this won't work since the way is already deleted
311     content private_deleted_way.to_xml
312     delete :delete, :id => private_deleted_way.id
313     assert_response :forbidden
314
315     # this shouldn't work as the way is used in a relation
316     content private_used_way.to_xml
317     delete :delete, :id => private_used_way.id
318     assert_response :forbidden,
319                     "shouldn't be able to delete a way used in a relation (#{@response.body}), when done by a private user"
320
321     # this won't work since the way never existed
322     delete :delete, :id => 0
323     assert_response :forbidden
324
325     ### Now check with a public user
326     # now set auth
327     basic_authorization(user.email, "test")
328
329     # this shouldn't work as with the 0.6 api we need pay load to delete
330     delete :delete, :id => way.id
331     assert_response :bad_request
332
333     # Now try without having a changeset
334     content "<osm><way id='#{way.id}'/></osm>"
335     delete :delete, :id => way.id
336     assert_response :bad_request
337
338     # try to delete with an invalid (closed) changeset
339     content update_changeset(way.to_xml, closed_changeset.id)
340     delete :delete, :id => way.id
341     assert_response :conflict
342
343     # try to delete with an invalid (non-existent) changeset
344     content update_changeset(way.to_xml, 0)
345     delete :delete, :id => way.id
346     assert_response :conflict
347
348     # Now try with a valid changeset
349     content way.to_xml
350     delete :delete, :id => way.id
351     assert_response :success
352
353     # check the returned value - should be the new version number
354     # valid delete should return the new version number, which should
355     # be greater than the old version number
356     assert @response.body.to_i > way.version,
357            "delete request should return a new version number for way"
358
359     # this won't work since the way is already deleted
360     content deleted_way.to_xml
361     delete :delete, :id => deleted_way.id
362     assert_response :gone
363
364     # this shouldn't work as the way is used in a relation
365     content used_way.to_xml
366     delete :delete, :id => used_way.id
367     assert_response :precondition_failed,
368                     "shouldn't be able to delete a way used in a relation (#{@response.body})"
369     assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
370
371     # this won't work since the way never existed
372     delete :delete, :id => 0
373     assert_response :not_found
374   end
375
376   ##
377   # tests whether the API works and prevents incorrect use while trying
378   # to update ways.
379   def test_update
380     private_user = create(:user, :data_public => false)
381     private_way = create(:way, :changeset => create(:changeset, :user => private_user))
382     user = create(:user)
383     way = create(:way, :changeset => create(:changeset, :user => user))
384     node = create(:node)
385     create(:way_node, :way => private_way, :node => node)
386     create(:way_node, :way => way, :node => node)
387
388     ## First test with no user credentials
389     # try and update a way without authorisation
390     content way.to_xml
391     put :update, :id => way.id
392     assert_response :unauthorized
393
394     ## Second test with the private user
395
396     # setup auth
397     basic_authorization(private_user.email, "test")
398
399     ## trying to break changesets
400
401     # try and update in someone else's changeset
402     content update_changeset(private_way.to_xml,
403                              create(:changeset).id)
404     put :update, :id => private_way.id
405     assert_require_public_data "update with other user's changeset should be forbidden when date isn't public"
406
407     # try and update in a closed changeset
408     content update_changeset(private_way.to_xml,
409                              create(:changeset, :closed, :user => private_user))
410     put :update, :id => private_way.id
411     assert_require_public_data "update with closed changeset should be forbidden, when data isn't public"
412
413     # try and update in a non-existant changeset
414     content update_changeset(private_way.to_xml, 0)
415     put :update, :id => private_way.id
416     assert_require_public_data("update with changeset=0 should be forbidden, when data isn't public")
417
418     ## try and submit invalid updates
419     content xml_replace_node(private_way.to_xml, node.id, 9999)
420     put :update, :id => private_way.id
421     assert_require_public_data "way with non-existent node should be forbidden, when data isn't public"
422
423     content xml_replace_node(private_way.to_xml, node.id, create(:node, :deleted).id)
424     put :update, :id => private_way.id
425     assert_require_public_data "way with deleted node should be forbidden, when data isn't public"
426
427     ## finally, produce a good request which will still not work
428     content private_way.to_xml
429     put :update, :id => private_way.id
430     assert_require_public_data "should have failed with a forbidden when data isn't public"
431
432     ## Finally test with the public user
433
434     # setup auth
435     basic_authorization(user.email, "test")
436
437     ## trying to break changesets
438
439     # try and update in someone else's changeset
440     content update_changeset(way.to_xml,
441                              create(:changeset).id)
442     put :update, :id => way.id
443     assert_response :conflict, "update with other user's changeset should be rejected"
444
445     # try and update in a closed changeset
446     content update_changeset(way.to_xml,
447                              changesets(:normal_user_closed_change).id)
448     put :update, :id => way.id
449     assert_response :conflict, "update with closed changeset should be rejected"
450
451     # try and update in a non-existant changeset
452     content update_changeset(way.to_xml, 0)
453     put :update, :id => way.id
454     assert_response :conflict, "update with changeset=0 should be rejected"
455
456     ## try and submit invalid updates
457     content xml_replace_node(way.to_xml, node.id, 9999)
458     put :update, :id => way.id
459     assert_response :precondition_failed, "way with non-existent node should be rejected"
460
461     content xml_replace_node(way.to_xml, node.id, create(:node, :deleted).id)
462     put :update, :id => way.id
463     assert_response :precondition_failed, "way with deleted node should be rejected"
464
465     ## next, attack the versioning
466     current_way_version = way.version
467
468     # try and submit a version behind
469     content xml_attr_rewrite(way.to_xml,
470                              "version", current_way_version - 1)
471     put :update, :id => way.id
472     assert_response :conflict, "should have failed on old version number"
473
474     # try and submit a version ahead
475     content xml_attr_rewrite(way.to_xml,
476                              "version", current_way_version + 1)
477     put :update, :id => way.id
478     assert_response :conflict, "should have failed on skipped version number"
479
480     # try and submit total crap in the version field
481     content xml_attr_rewrite(way.to_xml,
482                              "version", "p1r4t3s!")
483     put :update, :id => way.id
484     assert_response :conflict,
485                     "should not be able to put 'p1r4at3s!' in the version field"
486
487     ## try an update with the wrong ID
488     content create(:way).to_xml
489     put :update, :id => way.id
490     assert_response :bad_request,
491                     "should not be able to update a way with a different ID from the XML"
492
493     ## try an update with a minimal valid XML doc which isn't a well-formed OSM doc.
494     content "<update/>"
495     put :update, :id => way.id
496     assert_response :bad_request,
497                     "should not be able to update a way with non-OSM XML doc."
498
499     ## finally, produce a good request which should work
500     content way.to_xml
501     put :update, :id => way.id
502     assert_response :success, "a valid update request failed"
503   end
504
505   # ------------------------------------------------------------
506   # test tags handling
507   # ------------------------------------------------------------
508
509   ##
510   # Try adding a new tag to a way
511   def test_add_tags
512     ## Try with the non-public user
513     # setup auth
514     basic_authorization(users(:normal_user).email, "test")
515
516     # add an identical tag to the way
517     tag_xml = XML::Node.new("tag")
518     tag_xml["k"] = "new"
519     tag_xml["v"] = "yes"
520
521     # add the tag into the existing xml
522     way_xml = current_ways(:visible_way).to_xml
523     way_xml.find("//osm/way").first << tag_xml
524
525     # try and upload it
526     content way_xml
527     put :update, :id => current_ways(:visible_way).id
528     assert_response :forbidden,
529                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
530
531     ## Now try with the public user
532     # setup auth
533     basic_authorization(users(:public_user).email, "test")
534
535     # add an identical tag to the way
536     tag_xml = XML::Node.new("tag")
537     tag_xml["k"] = "new"
538     tag_xml["v"] = "yes"
539
540     # add the tag into the existing xml
541     way_xml = current_ways(:visible_way).to_xml
542     way_xml.find("//osm/way").first << tag_xml
543
544     # try and upload it
545     content way_xml
546     put :update, :id => current_ways(:visible_way).id
547     assert_response :success,
548                     "adding a new tag to a way should succeed"
549     assert_equal current_ways(:visible_way).version + 1, @response.body.to_i
550   end
551
552   ##
553   # Try adding a duplicate of an existing tag to a way
554   def test_add_duplicate_tags
555     ## Try with the non-public user
556     # setup auth
557     basic_authorization(users(:normal_user).email, "test")
558
559     existing = create(:way_tag, :way => current_ways(:visible_way))
560
561     # add an identical tag to the way
562     tag_xml = XML::Node.new("tag")
563     tag_xml["k"] = existing.k
564     tag_xml["v"] = existing.v
565
566     # add the tag into the existing xml
567     way_xml = current_ways(:visible_way).to_xml
568     way_xml.find("//osm/way").first << tag_xml
569
570     # try and upload it
571     content way_xml
572     put :update, :id => current_ways(:visible_way).id
573     assert_response :forbidden,
574                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
575
576     ## Now try with the public user
577     # setup auth
578     basic_authorization(users(:public_user).email, "test")
579
580     # add an identical tag to the way
581     tag_xml = XML::Node.new("tag")
582     tag_xml["k"] = existing.k
583     tag_xml["v"] = existing.v
584
585     # add the tag into the existing xml
586     way_xml = current_ways(:visible_way).to_xml
587     way_xml.find("//osm/way").first << tag_xml
588
589     # try and upload it
590     content way_xml
591     put :update, :id => current_ways(:visible_way).id
592     assert_response :bad_request,
593                     "adding a duplicate tag to a way should fail with 'bad request'"
594     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{existing.k}", @response.body
595   end
596
597   ##
598   # Try adding a new duplicate tags to a way
599   def test_new_duplicate_tags
600     ## First test with the non-public user so should be rejected
601     # setup auth
602     basic_authorization(users(:normal_user).email, "test")
603
604     # create duplicate tag
605     tag_xml = XML::Node.new("tag")
606     tag_xml["k"] = "i_am_a_duplicate"
607     tag_xml["v"] = "foobar"
608
609     # add the tag into the existing xml
610     way_xml = current_ways(:visible_way).to_xml
611
612     # add two copies of the tag
613     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
614
615     # try and upload it
616     content way_xml
617     put :update, :id => current_ways(:visible_way).id
618     assert_response :forbidden,
619                     "adding new duplicate tags to a way using a non-public user should fail with 'forbidden'"
620
621     ## Now test with the public user
622     # setup auth
623     basic_authorization(users(:public_user).email, "test")
624
625     # create duplicate tag
626     tag_xml = XML::Node.new("tag")
627     tag_xml["k"] = "i_am_a_duplicate"
628     tag_xml["v"] = "foobar"
629
630     # add the tag into the existing xml
631     way_xml = current_ways(:visible_way).to_xml
632
633     # add two copies of the tag
634     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
635
636     # try and upload it
637     content way_xml
638     put :update, :id => current_ways(:visible_way).id
639     assert_response :bad_request,
640                     "adding new duplicate tags to a way should fail with 'bad request'"
641     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate", @response.body
642   end
643
644   ##
645   # Try adding a new duplicate tags to a way.
646   # But be a bit subtle - use unicode decoding ambiguities to use different
647   # binary strings which have the same decoding.
648   def test_invalid_duplicate_tags
649     ## First make sure that you can't with a non-public user
650     # setup auth
651     basic_authorization(users(:normal_user).email, "test")
652
653     # add the tag into the existing xml
654     way_str = "<osm><way changeset='1'>"
655     way_str << "<tag k='addr:housenumber' v='1'/>"
656     way_str << "<tag k='addr:housenumber' v='2'/>"
657     way_str << "</way></osm>"
658
659     # try and upload it
660     content way_str
661     put :create
662     assert_response :forbidden,
663                     "adding new duplicate tags to a way with a non-public user should fail with 'forbidden'"
664
665     ## Now do it with a public user
666     # setup auth
667     basic_authorization(users(:public_user).email, "test")
668
669     # add the tag into the existing xml
670     way_str = "<osm><way changeset='1'>"
671     way_str << "<tag k='addr:housenumber' v='1'/>"
672     way_str << "<tag k='addr:housenumber' v='2'/>"
673     way_str << "</way></osm>"
674
675     # try and upload it
676     content way_str
677     put :create
678     assert_response :bad_request,
679                     "adding new duplicate tags to a way should fail with 'bad request'"
680     assert_equal "Element way/ has duplicate tags with key addr:housenumber", @response.body
681   end
682
683   ##
684   # test that a call to ways_for_node returns all ways that contain the node
685   # and none that don't.
686   def test_ways_for_node
687     # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4
688     # *used* to use it but doesn't.
689     get :ways_for_node, :id => current_nodes(:used_node_1).id
690     assert_response :success
691     ways_xml = XML::Parser.string(@response.body).parse
692     assert_not_nil ways_xml, "failed to parse ways_for_node response"
693
694     # check that the set of IDs match expectations
695     expected_way_ids = [current_ways(:visible_way).id,
696                         current_ways(:used_way).id]
697     found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
698     assert_equal expected_way_ids.sort, found_way_ids.sort,
699                  "expected ways for node #{current_nodes(:used_node_1).id} did not match found"
700
701     # check the full ways to ensure we're not missing anything
702     expected_way_ids.each do |id|
703       way_xml = ways_xml.find("//osm/way[@id='#{id}']").first
704       assert_ways_are_equal(Way.find(id),
705                             Way.from_xml_node(way_xml))
706     end
707   end
708
709   ##
710   # update the changeset_id of a way element
711   def update_changeset(xml, changeset_id)
712     xml_attr_rewrite(xml, "changeset", changeset_id)
713   end
714
715   ##
716   # update an attribute in the way element
717   def xml_attr_rewrite(xml, name, value)
718     xml.find("//osm/way").first[name] = value.to_s
719     xml
720   end
721
722   ##
723   # replace a node in a way element
724   def xml_replace_node(xml, old_node, new_node)
725     xml.find("//osm/way/nd[@ref='#{old_node}']").first["ref"] = new_node.to_s
726     xml
727   end
728 end