Fix rubocop-minitest warnings
[rails.git] / test / controllers / api / changesets_controller_test.rb
1 require "test_helper"
2
3 module Api
4   class ChangesetsControllerTest < ActionController::TestCase
5     ##
6     # test all routes which lead to this controller
7     def test_routes
8       assert_routing(
9         { :path => "/api/0.6/changeset/create", :method => :put },
10         { :controller => "api/changesets", :action => "create" }
11       )
12       assert_routing(
13         { :path => "/api/0.6/changeset/1/upload", :method => :post },
14         { :controller => "api/changesets", :action => "upload", :id => "1" }
15       )
16       assert_routing(
17         { :path => "/api/0.6/changeset/1/download", :method => :get },
18         { :controller => "api/changesets", :action => "download", :id => "1" }
19       )
20       assert_routing(
21         { :path => "/api/0.6/changeset/1", :method => :get },
22         { :controller => "api/changesets", :action => "show", :id => "1" }
23       )
24       assert_routing(
25         { :path => "/api/0.6/changeset/1/subscribe", :method => :post },
26         { :controller => "api/changesets", :action => "subscribe", :id => "1" }
27       )
28       assert_routing(
29         { :path => "/api/0.6/changeset/1/unsubscribe", :method => :post },
30         { :controller => "api/changesets", :action => "unsubscribe", :id => "1" }
31       )
32       assert_routing(
33         { :path => "/api/0.6/changeset/1", :method => :put },
34         { :controller => "api/changesets", :action => "update", :id => "1" }
35       )
36       assert_routing(
37         { :path => "/api/0.6/changeset/1/close", :method => :put },
38         { :controller => "api/changesets", :action => "close", :id => "1" }
39       )
40       assert_routing(
41         { :path => "/api/0.6/changesets", :method => :get },
42         { :controller => "api/changesets", :action => "query" }
43       )
44     end
45
46     # -----------------------
47     # Test simple changeset creation
48     # -----------------------
49
50     def test_create
51       basic_authorization create(:user, :data_public => false).email, "test"
52       # Create the first user's changeset
53       xml = "<osm><changeset>" \
54             "<tag k='created_by' v='osm test suite checking changesets'/>" \
55             "</changeset></osm>"
56       put :create, :body => xml
57       assert_require_public_data
58
59       basic_authorization create(:user).email, "test"
60       # Create the first user's changeset
61       xml = "<osm><changeset>" \
62             "<tag k='created_by' v='osm test suite checking changesets'/>" \
63             "</changeset></osm>"
64       put :create, :body => xml
65
66       assert_response :success, "Creation of changeset did not return sucess status"
67       newid = @response.body.to_i
68
69       # check end time, should be an hour ahead of creation time
70       cs = Changeset.find(newid)
71       duration = cs.closed_at - cs.created_at
72       # the difference can either be a rational, or a floating point number
73       # of seconds, depending on the code path taken :-(
74       if duration.class == Rational
75         assert_equal Rational(1, 24), duration, "initial idle timeout should be an hour (#{cs.created_at} -> #{cs.closed_at})"
76       else
77         # must be number of seconds...
78         assert_equal 3600, duration.round, "initial idle timeout should be an hour (#{cs.created_at} -> #{cs.closed_at})"
79       end
80
81       # checks if uploader was subscribed
82       assert_equal 1, cs.subscribers.length
83     end
84
85     def test_create_invalid
86       basic_authorization create(:user, :data_public => false).email, "test"
87       xml = "<osm><changeset></osm>"
88       put :create, :body => xml
89       assert_require_public_data
90
91       ## Try the public user
92       basic_authorization create(:user).email, "test"
93       xml = "<osm><changeset></osm>"
94       put :create, :body => xml
95       assert_response :bad_request, "creating a invalid changeset should fail"
96     end
97
98     def test_create_invalid_no_content
99       ## First check with no auth
100       put :create
101       assert_response :unauthorized, "shouldn't be able to create a changeset with no auth"
102
103       ## Now try to with a non-public user
104       basic_authorization create(:user, :data_public => false).email, "test"
105       put :create
106       assert_require_public_data
107
108       ## Try an inactive user
109       basic_authorization create(:user, :pending).email, "test"
110       put :create
111       assert_inactive_user
112
113       ## Now try to use a normal user
114       basic_authorization create(:user).email, "test"
115       put :create
116       assert_response :bad_request, "creating a changeset with no content should fail"
117     end
118
119     def test_create_wrong_method
120       basic_authorization create(:user).email, "test"
121       get :create
122       assert_response :method_not_allowed
123       post :create
124       assert_response :method_not_allowed
125     end
126
127     ##
128     # check that the changeset can be shown and returns the correct
129     # document structure.
130     def test_show
131       changeset = create(:changeset)
132
133       get :show, :params => { :id => changeset.id }
134       assert_response :success, "cannot get first changeset"
135
136       assert_select "osm[version='#{Settings.api_version}'][generator='OpenStreetMap server']", 1
137       assert_select "osm>changeset[id='#{changeset.id}']", 1
138       assert_select "osm>changeset>@open", "true"
139       assert_select "osm>changeset>@created_at", changeset.created_at.xmlschema
140       assert_select "osm>changeset>@closed_at", 0
141       assert_select "osm>changeset>discussion", 0
142
143       get :show, :params => { :id => changeset.id, :include_discussion => true }
144       assert_response :success, "cannot get first changeset with comments"
145
146       assert_select "osm[version='#{Settings.api_version}'][generator='OpenStreetMap server']", 1
147       assert_select "osm>changeset[id='#{changeset.id}']", 1
148       assert_select "osm>changeset>@open", "true"
149       assert_select "osm>changeset>@created_at", changeset.created_at.xmlschema
150       assert_select "osm>changeset>@closed_at", 0
151       assert_select "osm>changeset>discussion", 1
152       assert_select "osm>changeset>discussion>comment", 0
153
154       changeset = create(:changeset, :closed)
155       create_list(:changeset_comment, 3, :changeset_id => changeset.id)
156
157       get :show, :params => { :id => changeset.id, :include_discussion => true }
158       assert_response :success, "cannot get closed changeset with comments"
159
160       assert_select "osm[version='#{Settings.api_version}'][generator='OpenStreetMap server']", 1
161       assert_select "osm>changeset[id='#{changeset.id}']", 1
162       assert_select "osm>changeset>@open", "false"
163       assert_select "osm>changeset>@created_at", changeset.created_at.xmlschema
164       assert_select "osm>changeset>@closed_at", changeset.closed_at.xmlschema
165       assert_select "osm>changeset>discussion", 1
166       assert_select "osm>changeset>discussion>comment", 3
167     end
168
169     ##
170     # check that a changeset that doesn't exist returns an appropriate message
171     def test_show_not_found
172       [0, -32, 233455644, "afg", "213"].each do |id|
173         get :show, :params => { :id => id }
174         assert_response :not_found, "should get a not found"
175       rescue ActionController::UrlGenerationError => e
176         assert_match(/No route matches/, e.to_s)
177       end
178     end
179
180     ##
181     # test that the user who opened a change can close it
182     def test_close
183       private_user = create(:user, :data_public => false)
184       private_changeset = create(:changeset, :user => private_user)
185       user = create(:user)
186       changeset = create(:changeset, :user => user)
187
188       ## Try without authentication
189       put :close, :params => { :id => changeset.id }
190       assert_response :unauthorized
191
192       ## Try using the non-public user
193       basic_authorization private_user.email, "test"
194       put :close, :params => { :id => private_changeset.id }
195       assert_require_public_data
196
197       ## The try with the public user
198       basic_authorization user.email, "test"
199
200       cs_id = changeset.id
201       put :close, :params => { :id => cs_id }
202       assert_response :success
203
204       # test that it really is closed now
205       cs = Changeset.find(cs_id)
206       assert_not(cs.is_open?,
207                  "changeset should be closed now (#{cs.closed_at} > #{Time.now.getutc}.")
208     end
209
210     ##
211     # test that a different user can't close another user's changeset
212     def test_close_invalid
213       user = create(:user)
214       changeset = create(:changeset)
215
216       basic_authorization user.email, "test"
217
218       put :close, :params => { :id => changeset.id }
219       assert_response :conflict
220       assert_equal "The user doesn't own that changeset", @response.body
221     end
222
223     ##
224     # test that you can't close using another method
225     def test_close_method_invalid
226       user = create(:user)
227       changeset = create(:changeset, :user => user)
228
229       basic_authorization user.email, "test"
230
231       get :close, :params => { :id => changeset.id }
232       assert_response :method_not_allowed
233
234       post :close, :params => { :id => changeset.id }
235       assert_response :method_not_allowed
236     end
237
238     ##
239     # check that you can't close a changeset that isn't found
240     def test_close_not_found
241       cs_ids = [0, -132, "123"]
242
243       # First try to do it with no auth
244       cs_ids.each do |id|
245         put :close, :params => { :id => id }
246         assert_response :unauthorized, "Shouldn't be able close the non-existant changeset #{id}, when not authorized"
247       rescue ActionController::UrlGenerationError => e
248         assert_match(/No route matches/, e.to_s)
249       end
250
251       # Now try with auth
252       basic_authorization create(:user).email, "test"
253       cs_ids.each do |id|
254         put :close, :params => { :id => id }
255         assert_response :not_found, "The changeset #{id} doesn't exist, so can't be closed"
256       rescue ActionController::UrlGenerationError => e
257         assert_match(/No route matches/, e.to_s)
258       end
259     end
260
261     ##
262     # upload something simple, but valid and check that it can
263     # be read back ok
264     # Also try without auth and another user.
265     def test_upload_simple_valid
266       private_user = create(:user, :data_public => false)
267       private_changeset = create(:changeset, :user => private_user)
268       user = create(:user)
269       changeset = create(:changeset, :user => user)
270
271       node = create(:node)
272       way = create(:way)
273       relation = create(:relation)
274       other_relation = create(:relation)
275       # create some tags, since we test that they are removed later
276       create(:node_tag, :node => node)
277       create(:way_tag, :way => way)
278       create(:relation_tag, :relation => relation)
279
280       ## Try with no auth
281       changeset_id = changeset.id
282
283       # simple diff to change a node, way and relation by removing
284       # their tags
285       diff = <<~CHANGESET
286         <osmChange>
287          <modify>
288           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
289           <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
290            <nd ref='#{node.id}'/>
291           </way>
292          </modify>
293          <modify>
294           <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
295            <member type='way' role='some' ref='#{way.id}'/>
296            <member type='node' role='some' ref='#{node.id}'/>
297            <member type='relation' role='some' ref='#{other_relation.id}'/>
298           </relation>
299          </modify>
300         </osmChange>
301       CHANGESET
302
303       # upload it
304       post :upload, :params => { :id => changeset_id }, :body => diff
305       assert_response :unauthorized,
306                       "shouldn't be able to upload a simple valid diff to changeset: #{@response.body}"
307
308       ## Now try with a private user
309       basic_authorization private_user.email, "test"
310       changeset_id = private_changeset.id
311
312       # simple diff to change a node, way and relation by removing
313       # their tags
314       diff = <<~CHANGESET
315         <osmChange>
316          <modify>
317           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
318           <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
319            <nd ref='#{node.id}'/>
320           </way>
321          </modify>
322          <modify>
323           <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
324            <member type='way' role='some' ref='#{way.id}'/>
325            <member type='node' role='some' ref='#{node.id}'/>
326            <member type='relation' role='some' ref='#{other_relation.id}'/>
327           </relation>
328          </modify>
329         </osmChange>
330       CHANGESET
331
332       # upload it
333       post :upload, :params => { :id => changeset_id }, :body => diff
334       assert_response :forbidden,
335                       "can't upload a simple valid diff to changeset: #{@response.body}"
336
337       ## Now try with the public user
338       basic_authorization user.email, "test"
339       changeset_id = changeset.id
340
341       # simple diff to change a node, way and relation by removing
342       # their tags
343       diff = <<~CHANGESET
344         <osmChange>
345          <modify>
346           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
347           <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
348            <nd ref='#{node.id}'/>
349           </way>
350          </modify>
351          <modify>
352           <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
353            <member type='way' role='some' ref='#{way.id}'/>
354            <member type='node' role='some' ref='#{node.id}'/>
355            <member type='relation' role='some' ref='#{other_relation.id}'/>
356           </relation>
357          </modify>
358         </osmChange>
359       CHANGESET
360
361       # upload it
362       post :upload, :params => { :id => changeset_id }, :body => diff
363       assert_response :success,
364                       "can't upload a simple valid diff to changeset: #{@response.body}"
365
366       # check that the changes made it into the database
367       assert_equal 0, Node.find(node.id).tags.size, "node #{node.id} should now have no tags"
368       assert_equal 0, Way.find(way.id).tags.size, "way #{way.id} should now have no tags"
369       assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
370     end
371
372     ##
373     # upload something which creates new objects using placeholders
374     def test_upload_create_valid
375       user = create(:user)
376       changeset = create(:changeset, :user => user)
377       node = create(:node)
378       way = create(:way_with_nodes, :nodes_count => 2)
379       relation = create(:relation)
380
381       basic_authorization user.email, "test"
382
383       # simple diff to create a node way and relation using placeholders
384       diff = <<~CHANGESET
385         <osmChange>
386          <create>
387           <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
388            <tag k='foo' v='bar'/>
389            <tag k='baz' v='bat'/>
390           </node>
391           <way id='-1' changeset='#{changeset.id}'>
392            <nd ref='#{node.id}'/>
393           </way>
394          </create>
395          <create>
396           <relation id='-1' changeset='#{changeset.id}'>
397            <member type='way' role='some' ref='#{way.id}'/>
398            <member type='node' role='some' ref='#{node.id}'/>
399            <member type='relation' role='some' ref='#{relation.id}'/>
400           </relation>
401          </create>
402         </osmChange>
403       CHANGESET
404
405       # upload it
406       post :upload, :params => { :id => changeset.id }, :body => diff
407       assert_response :success,
408                       "can't upload a simple valid creation to changeset: #{@response.body}"
409
410       # check the returned payload
411       assert_select "diffResult[version='#{Settings.api_version}'][generator='OpenStreetMap server']", 1
412       assert_select "diffResult>node", 1
413       assert_select "diffResult>way", 1
414       assert_select "diffResult>relation", 1
415
416       # inspect the response to find out what the new element IDs are
417       doc = XML::Parser.string(@response.body).parse
418       new_node_id = doc.find("//diffResult/node").first["new_id"].to_i
419       new_way_id = doc.find("//diffResult/way").first["new_id"].to_i
420       new_rel_id = doc.find("//diffResult/relation").first["new_id"].to_i
421
422       # check the old IDs are all present and negative one
423       assert_equal(-1, doc.find("//diffResult/node").first["old_id"].to_i)
424       assert_equal(-1, doc.find("//diffResult/way").first["old_id"].to_i)
425       assert_equal(-1, doc.find("//diffResult/relation").first["old_id"].to_i)
426
427       # check the versions are present and equal one
428       assert_equal 1, doc.find("//diffResult/node").first["new_version"].to_i
429       assert_equal 1, doc.find("//diffResult/way").first["new_version"].to_i
430       assert_equal 1, doc.find("//diffResult/relation").first["new_version"].to_i
431
432       # check that the changes made it into the database
433       assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
434       assert_equal 0, Way.find(new_way_id).tags.size, "new way should have no tags"
435       assert_equal 0, Relation.find(new_rel_id).tags.size, "new relation should have no tags"
436     end
437
438     ##
439     # test a complex delete where we delete elements which rely on eachother
440     # in the same transaction.
441     def test_upload_delete
442       changeset = create(:changeset)
443       super_relation = create(:relation)
444       used_relation = create(:relation)
445       used_way = create(:way)
446       used_node = create(:node)
447       create(:relation_member, :relation => super_relation, :member => used_relation)
448       create(:relation_member, :relation => super_relation, :member => used_way)
449       create(:relation_member, :relation => super_relation, :member => used_node)
450
451       basic_authorization changeset.user.display_name, "test"
452
453       diff = XML::Document.new
454       diff.root = XML::Node.new "osmChange"
455       delete = XML::Node.new "delete"
456       diff.root << delete
457       delete << xml_node_for_relation(super_relation)
458       delete << xml_node_for_relation(used_relation)
459       delete << xml_node_for_way(used_way)
460       delete << xml_node_for_node(used_node)
461
462       # update the changeset to one that this user owns
463       %w[node way relation].each do |type|
464         delete.find("//osmChange/delete/#{type}").each do |n|
465           n["changeset"] = changeset.id.to_s
466         end
467       end
468
469       # upload it
470       post :upload, :params => { :id => changeset.id }, :body => diff.to_s
471       assert_response :success,
472                       "can't upload a deletion diff to changeset: #{@response.body}"
473
474       # check the response is well-formed
475       assert_select "diffResult>node", 1
476       assert_select "diffResult>way", 1
477       assert_select "diffResult>relation", 2
478
479       # check that everything was deleted
480       assert_not Node.find(used_node.id).visible
481       assert_not Way.find(used_way.id).visible
482       assert_not Relation.find(super_relation.id).visible
483       assert_not Relation.find(used_relation.id).visible
484     end
485
486     ##
487     # test uploading a delete with no lat/lon, as they are optional in
488     # the osmChange spec.
489     def test_upload_nolatlon_delete
490       node = create(:node)
491       changeset = create(:changeset)
492
493       basic_authorization changeset.user.display_name, "test"
494       diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
495
496       # upload it
497       post :upload, :params => { :id => changeset.id }, :body => diff
498       assert_response :success,
499                       "can't upload a deletion diff to changeset: #{@response.body}"
500
501       # check the response is well-formed
502       assert_select "diffResult>node", 1
503
504       # check that everything was deleted
505       assert_not Node.find(node.id).visible
506     end
507
508     def test_repeated_changeset_create
509       3.times do
510         basic_authorization create(:user).email, "test"
511
512         # create a temporary changeset
513         xml = "<osm><changeset>" \
514               "<tag k='created_by' v='osm test suite checking changesets'/>" \
515               "</changeset></osm>"
516         assert_difference "Changeset.count", 1 do
517           put :create, :body => xml
518         end
519         assert_response :success
520       end
521     end
522
523     def test_upload_large_changeset
524       basic_authorization create(:user).email, "test"
525
526       # create a changeset
527       put :create, :body => "<osm><changeset/></osm>"
528       assert_response :success, "Should be able to create a changeset: #{@response.body}"
529       changeset_id = @response.body.to_i
530
531       # upload some widely-spaced nodes, spiralling positive and negative
532       diff = <<~CHANGESET
533         <osmChange>
534          <create>
535           <node id='-1' lon='-20' lat='-10' changeset='#{changeset_id}'/>
536           <node id='-10' lon='20'  lat='10' changeset='#{changeset_id}'/>
537           <node id='-2' lon='-40' lat='-20' changeset='#{changeset_id}'/>
538           <node id='-11' lon='40'  lat='20' changeset='#{changeset_id}'/>
539           <node id='-3' lon='-60' lat='-30' changeset='#{changeset_id}'/>
540           <node id='-12' lon='60'  lat='30' changeset='#{changeset_id}'/>
541           <node id='-4' lon='-80' lat='-40' changeset='#{changeset_id}'/>
542           <node id='-13' lon='80'  lat='40' changeset='#{changeset_id}'/>
543           <node id='-5' lon='-100' lat='-50' changeset='#{changeset_id}'/>
544           <node id='-14' lon='100'  lat='50' changeset='#{changeset_id}'/>
545           <node id='-6' lon='-120' lat='-60' changeset='#{changeset_id}'/>
546           <node id='-15' lon='120'  lat='60' changeset='#{changeset_id}'/>
547           <node id='-7' lon='-140' lat='-70' changeset='#{changeset_id}'/>
548           <node id='-16' lon='140'  lat='70' changeset='#{changeset_id}'/>
549           <node id='-8' lon='-160' lat='-80' changeset='#{changeset_id}'/>
550           <node id='-17' lon='160'  lat='80' changeset='#{changeset_id}'/>
551           <node id='-9' lon='-179.9' lat='-89.9' changeset='#{changeset_id}'/>
552           <node id='-18' lon='179.9'  lat='89.9' changeset='#{changeset_id}'/>
553          </create>
554         </osmChange>
555       CHANGESET
556
557       # upload it, which used to cause an error like "PGError: ERROR:
558       # integer out of range" (bug #2152). but shouldn't any more.
559       post :upload, :params => { :id => changeset_id }, :body => diff
560       assert_response :success,
561                       "can't upload a spatially-large diff to changeset: #{@response.body}"
562
563       # check that the changeset bbox is within bounds
564       cs = Changeset.find(changeset_id)
565       assert cs.min_lon >= -180 * GeoRecord::SCALE, "Minimum longitude (#{cs.min_lon / GeoRecord::SCALE}) should be >= -180 to be valid."
566       assert cs.max_lon <= 180 * GeoRecord::SCALE, "Maximum longitude (#{cs.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
567       assert cs.min_lat >= -90 * GeoRecord::SCALE, "Minimum latitude (#{cs.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
568       assert cs.max_lat <= 90 * GeoRecord::SCALE, "Maximum latitude (#{cs.max_lat / GeoRecord::SCALE}) should be <= 90 to be valid."
569     end
570
571     ##
572     # test that deleting stuff in a transaction doesn't bypass the checks
573     # to ensure that used elements are not deleted.
574     def test_upload_delete_invalid
575       changeset = create(:changeset)
576       relation = create(:relation)
577       other_relation = create(:relation)
578       used_way = create(:way)
579       used_node = create(:node)
580       create(:relation_member, :relation => relation, :member => used_way)
581       create(:relation_member, :relation => relation, :member => used_node)
582
583       basic_authorization changeset.user.email, "test"
584
585       diff = XML::Document.new
586       diff.root = XML::Node.new "osmChange"
587       delete = XML::Node.new "delete"
588       diff.root << delete
589       delete << xml_node_for_relation(other_relation)
590       delete << xml_node_for_way(used_way)
591       delete << xml_node_for_node(used_node)
592
593       # update the changeset to one that this user owns
594       %w[node way relation].each do |type|
595         delete.find("//osmChange/delete/#{type}").each do |n|
596           n["changeset"] = changeset.id.to_s
597         end
598       end
599
600       # upload it
601       post :upload, :params => { :id => changeset.id }, :body => diff.to_s
602       assert_response :precondition_failed,
603                       "shouldn't be able to upload a invalid deletion diff: #{@response.body}"
604       assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
605
606       # check that nothing was, in fact, deleted
607       assert Node.find(used_node.id).visible
608       assert Way.find(used_way.id).visible
609       assert Relation.find(relation.id).visible
610       assert Relation.find(other_relation.id).visible
611     end
612
613     ##
614     # test that a conditional delete of an in use object works.
615     def test_upload_delete_if_unused
616       changeset = create(:changeset)
617       super_relation = create(:relation)
618       used_relation = create(:relation)
619       used_way = create(:way)
620       used_node = create(:node)
621       create(:relation_member, :relation => super_relation, :member => used_relation)
622       create(:relation_member, :relation => super_relation, :member => used_way)
623       create(:relation_member, :relation => super_relation, :member => used_node)
624
625       basic_authorization changeset.user.email, "test"
626
627       diff = XML::Document.new
628       diff.root = XML::Node.new "osmChange"
629       delete = XML::Node.new "delete"
630       diff.root << delete
631       delete["if-unused"] = ""
632       delete << xml_node_for_relation(used_relation)
633       delete << xml_node_for_way(used_way)
634       delete << xml_node_for_node(used_node)
635
636       # update the changeset to one that this user owns
637       %w[node way relation].each do |type|
638         delete.find("//osmChange/delete/#{type}").each do |n|
639           n["changeset"] = changeset.id.to_s
640         end
641       end
642
643       # upload it
644       post :upload, :params => { :id => changeset.id }, :body => diff.to_s
645       assert_response :success,
646                       "can't do a conditional delete of in use objects: #{@response.body}"
647
648       # check the returned payload
649       assert_select "diffResult[version='#{Settings.api_version}'][generator='OpenStreetMap server']", 1
650       assert_select "diffResult>node", 1
651       assert_select "diffResult>way", 1
652       assert_select "diffResult>relation", 1
653
654       # parse the response
655       doc = XML::Parser.string(@response.body).parse
656
657       # check the old IDs are all present and what we expect
658       assert_equal used_node.id, doc.find("//diffResult/node").first["old_id"].to_i
659       assert_equal used_way.id, doc.find("//diffResult/way").first["old_id"].to_i
660       assert_equal used_relation.id, doc.find("//diffResult/relation").first["old_id"].to_i
661
662       # check the new IDs are all present and unchanged
663       assert_equal used_node.id, doc.find("//diffResult/node").first["new_id"].to_i
664       assert_equal used_way.id, doc.find("//diffResult/way").first["new_id"].to_i
665       assert_equal used_relation.id, doc.find("//diffResult/relation").first["new_id"].to_i
666
667       # check the new versions are all present and unchanged
668       assert_equal used_node.version, doc.find("//diffResult/node").first["new_version"].to_i
669       assert_equal used_way.version, doc.find("//diffResult/way").first["new_version"].to_i
670       assert_equal used_relation.version, doc.find("//diffResult/relation").first["new_version"].to_i
671
672       # check that nothing was, in fact, deleted
673       assert Node.find(used_node.id).visible
674       assert Way.find(used_way.id).visible
675       assert Relation.find(used_relation.id).visible
676     end
677
678     ##
679     # upload an element with a really long tag value
680     def test_upload_invalid_too_long_tag
681       changeset = create(:changeset)
682
683       basic_authorization changeset.user.email, "test"
684
685       # simple diff to create a node way and relation using placeholders
686       diff = <<~CHANGESET
687         <osmChange>
688          <create>
689           <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
690            <tag k='foo' v='#{'x' * 256}'/>
691           </node>
692          </create>
693         </osmChange>
694       CHANGESET
695
696       # upload it
697       post :upload, :params => { :id => changeset.id }, :body => diff
698       assert_response :bad_request,
699                       "shoudln't be able to upload too long a tag to changeset: #{@response.body}"
700     end
701
702     ##
703     # upload something which creates new objects and inserts them into
704     # existing containers using placeholders.
705     def test_upload_complex
706       way = create(:way)
707       node = create(:node)
708       relation = create(:relation)
709       create(:way_node, :way => way, :node => node)
710
711       changeset = create(:changeset)
712
713       basic_authorization changeset.user.email, "test"
714
715       # simple diff to create a node way and relation using placeholders
716       diff = <<~CHANGESET
717         <osmChange>
718          <create>
719           <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
720            <tag k='foo' v='bar'/>
721            <tag k='baz' v='bat'/>
722           </node>
723          </create>
724          <modify>
725           <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
726            <nd ref='-1'/>
727            <nd ref='#{node.id}'/>
728           </way>
729           <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
730            <member type='way' role='some' ref='#{way.id}'/>
731            <member type='node' role='some' ref='-1'/>
732            <member type='relation' role='some' ref='#{relation.id}'/>
733           </relation>
734          </modify>
735         </osmChange>
736       CHANGESET
737
738       # upload it
739       post :upload, :params => { :id => changeset.id }, :body => diff
740       assert_response :success,
741                       "can't upload a complex diff to changeset: #{@response.body}"
742
743       # check the returned payload
744       assert_select "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1
745       assert_select "diffResult>node", 1
746       assert_select "diffResult>way", 1
747       assert_select "diffResult>relation", 1
748
749       # inspect the response to find out what the new element IDs are
750       doc = XML::Parser.string(@response.body).parse
751       new_node_id = doc.find("//diffResult/node").first["new_id"].to_i
752
753       # check that the changes made it into the database
754       assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
755       assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
756       Relation.find(relation.id).members.each do |type, id, _role|
757         assert_equal new_node_id, id, "relation should contain new node" if type == "node"
758       end
759     end
760
761     ##
762     # create a diff which references several changesets, which should cause
763     # a rollback and none of the diff gets committed
764     def test_upload_invalid_changesets
765       changeset = create(:changeset)
766       other_changeset = create(:changeset, :user => changeset.user)
767       node = create(:node)
768       way = create(:way)
769       relation = create(:relation)
770       other_relation = create(:relation)
771
772       basic_authorization changeset.user.email, "test"
773
774       # simple diff to create a node way and relation using placeholders
775       diff = <<~CHANGESET
776         <osmChange>
777          <modify>
778           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
779           <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
780            <nd ref='#{node.id}'/>
781           </way>
782          </modify>
783          <modify>
784           <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
785            <member type='way' role='some' ref='#{way.id}'/>
786            <member type='node' role='some' ref='#{node.id}'/>
787            <member type='relation' role='some' ref='#{other_relation.id}'/>
788           </relation>
789          </modify>
790          <create>
791           <node id='-1' lon='0' lat='0' changeset='#{other_changeset.id}'>
792            <tag k='foo' v='bar'/>
793            <tag k='baz' v='bat'/>
794           </node>
795          </create>
796         </osmChange>
797       CHANGESET
798
799       # upload it
800       post :upload, :params => { :id => changeset.id }, :body => diff
801       assert_response :conflict,
802                       "uploading a diff with multiple changesets should have failed"
803
804       # check that objects are unmodified
805       assert_nodes_are_equal(node, Node.find(node.id))
806       assert_ways_are_equal(way, Way.find(way.id))
807       assert_relations_are_equal(relation, Relation.find(relation.id))
808     end
809
810     ##
811     # upload multiple versions of the same element in the same diff.
812     def test_upload_multiple_valid
813       node = create(:node)
814       changeset = create(:changeset)
815       basic_authorization changeset.user.email, "test"
816
817       # change the location of a node multiple times, each time referencing
818       # the last version. doesn't this depend on version numbers being
819       # sequential?
820       diff = <<~CHANGESET
821         <osmChange>
822          <modify>
823           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
824           <node id='#{node.id}' lon='1' lat='0' changeset='#{changeset.id}' version='2'/>
825           <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='3'/>
826           <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='4'/>
827           <node id='#{node.id}' lon='2' lat='2' changeset='#{changeset.id}' version='5'/>
828           <node id='#{node.id}' lon='3' lat='2' changeset='#{changeset.id}' version='6'/>
829           <node id='#{node.id}' lon='3' lat='3' changeset='#{changeset.id}' version='7'/>
830           <node id='#{node.id}' lon='9' lat='9' changeset='#{changeset.id}' version='8'/>
831          </modify>
832         </osmChange>
833       CHANGESET
834
835       # upload it
836       post :upload, :params => { :id => changeset.id }, :body => diff
837       assert_response :success,
838                       "can't upload multiple versions of an element in a diff: #{@response.body}"
839
840       # check the response is well-formed. its counter-intuitive, but the
841       # API will return multiple elements with the same ID and different
842       # version numbers for each change we made.
843       assert_select "diffResult>node", 8
844     end
845
846     ##
847     # upload multiple versions of the same element in the same diff, but
848     # keep the version numbers the same.
849     def test_upload_multiple_duplicate
850       node = create(:node)
851       changeset = create(:changeset)
852
853       basic_authorization changeset.user.email, "test"
854
855       diff = <<~CHANGESET
856         <osmChange>
857          <modify>
858           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
859           <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
860          </modify>
861         </osmChange>
862       CHANGESET
863
864       # upload it
865       post :upload, :params => { :id => changeset.id }, :body => diff
866       assert_response :conflict,
867                       "shouldn't be able to upload the same element twice in a diff: #{@response.body}"
868     end
869
870     ##
871     # try to upload some elements without specifying the version
872     def test_upload_missing_version
873       changeset = create(:changeset)
874
875       basic_authorization changeset.user.email, "test"
876
877       diff = <<~CHANGESET
878         <osmChange>
879          <modify>
880          <node id='1' lon='1' lat='1' changeset='#{changeset.id}'/>
881          </modify>
882         </osmChange>
883       CHANGESET
884
885       # upload it
886       post :upload, :params => { :id => changeset.id }, :body => diff
887       assert_response :bad_request,
888                       "shouldn't be able to upload an element without version: #{@response.body}"
889     end
890
891     ##
892     # try to upload with commands other than create, modify, or delete
893     def test_action_upload_invalid
894       changeset = create(:changeset)
895
896       basic_authorization changeset.user.email, "test"
897
898       diff = <<~CHANGESET
899         <osmChange>
900           <ping>
901            <node id='1' lon='1' lat='1' changeset='#{changeset.id}' />
902           </ping>
903         </osmChange>
904       CHANGESET
905       post :upload, :params => { :id => changeset.id }, :body => diff
906       assert_response :bad_request, "Shouldn't be able to upload a diff with the action ping"
907       assert_equal @response.body, "Unknown action ping, choices are create, modify, delete"
908     end
909
910     ##
911     # upload a valid changeset which has a mixture of whitespace
912     # to check a bug reported by ivansanchez (#1565).
913     def test_upload_whitespace_valid
914       changeset = create(:changeset)
915       node = create(:node)
916       way = create(:way_with_nodes, :nodes_count => 2)
917       relation = create(:relation)
918       other_relation = create(:relation)
919       create(:relation_tag, :relation => relation)
920
921       basic_authorization changeset.user.email, "test"
922
923       diff = <<~CHANGESET
924         <osmChange>
925          <modify><node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}'
926           version='1'></node>
927           <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='2'><tag k='k' v='v'/></node></modify>
928          <modify>
929          <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'><member
930            type='way' role='some' ref='#{way.id}'/><member
931             type='node' role='some' ref='#{node.id}'/>
932            <member type='relation' role='some' ref='#{other_relation.id}'/>
933           </relation>
934          </modify></osmChange>
935       CHANGESET
936
937       # upload it
938       post :upload, :params => { :id => changeset.id }, :body => diff
939       assert_response :success,
940                       "can't upload a valid diff with whitespace variations to changeset: #{@response.body}"
941
942       # check the response is well-formed
943       assert_select "diffResult>node", 2
944       assert_select "diffResult>relation", 1
945
946       # check that the changes made it into the database
947       assert_equal 1, Node.find(node.id).tags.size, "node #{node.id} should now have one tag"
948       assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
949     end
950
951     ##
952     # test that a placeholder can be reused within the same upload.
953     def test_upload_reuse_placeholder_valid
954       changeset = create(:changeset)
955
956       basic_authorization changeset.user.email, "test"
957
958       diff = <<~CHANGESET
959         <osmChange>
960          <create>
961           <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
962            <tag k="foo" v="bar"/>
963           </node>
964          </create>
965          <modify>
966           <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
967          </modify>
968          <delete>
969           <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
970          </delete>
971         </osmChange>
972       CHANGESET
973
974       # upload it
975       post :upload, :params => { :id => changeset.id }, :body => diff
976       assert_response :success,
977                       "can't upload a valid diff with re-used placeholders to changeset: #{@response.body}"
978
979       # check the response is well-formed
980       assert_select "diffResult>node", 3
981       assert_select "diffResult>node[old_id='-1']", 3
982     end
983
984     ##
985     # test what happens if a diff upload re-uses placeholder IDs in an
986     # illegal way.
987     def test_upload_placeholder_invalid
988       changeset = create(:changeset)
989
990       basic_authorization changeset.user.email, "test"
991
992       diff = <<~CHANGESET
993         <osmChange>
994          <create>
995           <node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
996           <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
997           <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
998          </create>
999         </osmChange>
1000       CHANGESET
1001
1002       # upload it
1003       post :upload, :params => { :id => changeset.id }, :body => diff
1004       assert_response :bad_request,
1005                       "shouldn't be able to re-use placeholder IDs"
1006     end
1007
1008     ##
1009     # test that uploading a way referencing invalid placeholders gives a
1010     # proper error, not a 500.
1011     def test_upload_placeholder_invalid_way
1012       changeset = create(:changeset)
1013       way = create(:way)
1014
1015       basic_authorization changeset.user.email, "test"
1016
1017       diff = <<~CHANGESET
1018         <osmChange>
1019          <create>
1020           <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1021           <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1022           <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1023           <way id="-1" changeset="#{changeset.id}" version="1">
1024            <nd ref="-1"/>
1025            <nd ref="-2"/>
1026            <nd ref="-3"/>
1027            <nd ref="-4"/>
1028           </way>
1029          </create>
1030         </osmChange>
1031       CHANGESET
1032
1033       # upload it
1034       post :upload, :params => { :id => changeset.id }, :body => diff
1035       assert_response :bad_request,
1036                       "shouldn't be able to use invalid placeholder IDs"
1037       assert_equal "Placeholder node not found for reference -4 in way -1", @response.body
1038
1039       # the same again, but this time use an existing way
1040       diff = <<~CHANGESET
1041         <osmChange>
1042          <create>
1043           <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1044           <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1045           <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1046           <way id="#{way.id}" changeset="#{changeset.id}" version="1">
1047            <nd ref="-1"/>
1048            <nd ref="-2"/>
1049            <nd ref="-3"/>
1050            <nd ref="-4"/>
1051           </way>
1052          </create>
1053         </osmChange>
1054       CHANGESET
1055
1056       # upload it
1057       post :upload, :params => { :id => changeset.id }, :body => diff
1058       assert_response :bad_request,
1059                       "shouldn't be able to use invalid placeholder IDs"
1060       assert_equal "Placeholder node not found for reference -4 in way #{way.id}", @response.body
1061     end
1062
1063     ##
1064     # test that uploading a relation referencing invalid placeholders gives a
1065     # proper error, not a 500.
1066     def test_upload_placeholder_invalid_relation
1067       changeset = create(:changeset)
1068       relation = create(:relation)
1069
1070       basic_authorization changeset.user.email, "test"
1071
1072       diff = <<~CHANGESET
1073         <osmChange>
1074          <create>
1075           <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1076           <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1077           <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1078           <relation id="-1" changeset="#{changeset.id}" version="1">
1079            <member type="node" role="foo" ref="-1"/>
1080            <member type="node" role="foo" ref="-2"/>
1081            <member type="node" role="foo" ref="-3"/>
1082            <member type="node" role="foo" ref="-4"/>
1083           </relation>
1084          </create>
1085         </osmChange>
1086       CHANGESET
1087
1088       # upload it
1089       post :upload, :params => { :id => changeset.id }, :body => diff
1090       assert_response :bad_request,
1091                       "shouldn't be able to use invalid placeholder IDs"
1092       assert_equal "Placeholder Node not found for reference -4 in relation -1.", @response.body
1093
1094       # the same again, but this time use an existing relation
1095       diff = <<~CHANGESET
1096         <osmChange>
1097          <create>
1098           <node id="-1" lon="0" lat="0" changeset="#{changeset.id}" version="1"/>
1099           <node id="-2" lon="1" lat="1" changeset="#{changeset.id}" version="1"/>
1100           <node id="-3" lon="2" lat="2" changeset="#{changeset.id}" version="1"/>
1101           <relation id="#{relation.id}" changeset="#{changeset.id}" version="1">
1102            <member type="node" role="foo" ref="-1"/>
1103            <member type="node" role="foo" ref="-2"/>
1104            <member type="node" role="foo" ref="-3"/>
1105            <member type="way" role="bar" ref="-1"/>
1106           </relation>
1107          </create>
1108         </osmChange>
1109       CHANGESET
1110
1111       # upload it
1112       post :upload, :params => { :id => changeset.id }, :body => diff
1113       assert_response :bad_request,
1114                       "shouldn't be able to use invalid placeholder IDs"
1115       assert_equal "Placeholder Way not found for reference -1 in relation #{relation.id}.", @response.body
1116     end
1117
1118     ##
1119     # test what happens if a diff is uploaded containing only a node
1120     # move.
1121     def test_upload_node_move
1122       basic_authorization create(:user).email, "test"
1123
1124       xml = "<osm><changeset>" \
1125             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1126             "</changeset></osm>"
1127       put :create, :body => xml
1128       assert_response :success
1129       changeset_id = @response.body.to_i
1130
1131       old_node = create(:node, :lat => 1, :lon => 1)
1132
1133       diff = XML::Document.new
1134       diff.root = XML::Node.new "osmChange"
1135       modify = XML::Node.new "modify"
1136       xml_old_node = xml_node_for_node(old_node)
1137       xml_old_node["lat"] = 2.0.to_s
1138       xml_old_node["lon"] = 2.0.to_s
1139       xml_old_node["changeset"] = changeset_id.to_s
1140       modify << xml_old_node
1141       diff.root << modify
1142
1143       # upload it
1144       post :upload, :params => { :id => changeset_id }, :body => diff.to_s
1145       assert_response :success,
1146                       "diff should have uploaded OK"
1147
1148       # check the bbox
1149       changeset = Changeset.find(changeset_id)
1150       assert_equal 1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 1 degree"
1151       assert_equal 2 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2 degrees"
1152       assert_equal 1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1 degree"
1153       assert_equal 2 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 2 degrees"
1154     end
1155
1156     ##
1157     # test what happens if a diff is uploaded adding a node to a way.
1158     def test_upload_way_extend
1159       basic_authorization create(:user).email, "test"
1160
1161       xml = "<osm><changeset>" \
1162             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1163             "</changeset></osm>"
1164       put :create, :body => xml
1165       assert_response :success
1166       changeset_id = @response.body.to_i
1167
1168       old_way = create(:way)
1169       create(:way_node, :way => old_way, :node => create(:node, :lat => 1, :lon => 1))
1170
1171       diff = XML::Document.new
1172       diff.root = XML::Node.new "osmChange"
1173       modify = XML::Node.new "modify"
1174       xml_old_way = xml_node_for_way(old_way)
1175       nd_ref = XML::Node.new "nd"
1176       nd_ref["ref"] = create(:node, :lat => 3, :lon => 3).id.to_s
1177       xml_old_way << nd_ref
1178       xml_old_way["changeset"] = changeset_id.to_s
1179       modify << xml_old_way
1180       diff.root << modify
1181
1182       # upload it
1183       post :upload, :params => { :id => changeset_id }, :body => diff.to_s
1184       assert_response :success,
1185                       "diff should have uploaded OK"
1186
1187       # check the bbox
1188       changeset = Changeset.find(changeset_id)
1189       assert_equal 1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 1 degree"
1190       assert_equal 3 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 3 degrees"
1191       assert_equal 1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1 degree"
1192       assert_equal 3 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 3 degrees"
1193     end
1194
1195     ##
1196     # test for more issues in #1568
1197     def test_upload_empty_invalid
1198       changeset = create(:changeset)
1199
1200       basic_authorization changeset.user.email, "test"
1201
1202       ["<osmChange/>",
1203        "<osmChange></osmChange>",
1204        "<osmChange><modify/></osmChange>",
1205        "<osmChange><modify></modify></osmChange>"].each do |diff|
1206         # upload it
1207         post :upload, :params => { :id => changeset.id }, :body => diff
1208         assert_response(:success, "should be able to upload " \
1209                         "empty changeset: " + diff)
1210       end
1211     end
1212
1213     ##
1214     # test that the X-Error-Format header works to request XML errors
1215     def test_upload_xml_errors
1216       changeset = create(:changeset)
1217       node = create(:node)
1218       create(:relation_member, :member => node)
1219
1220       basic_authorization changeset.user.email, "test"
1221
1222       # try and delete a node that is in use
1223       diff = XML::Document.new
1224       diff.root = XML::Node.new "osmChange"
1225       delete = XML::Node.new "delete"
1226       diff.root << delete
1227       delete << xml_node_for_node(node)
1228
1229       # upload it
1230       error_format "xml"
1231       post :upload, :params => { :id => changeset.id }, :body => diff.to_s
1232       assert_response :success,
1233                       "failed to return error in XML format"
1234
1235       # check the returned payload
1236       assert_select "osmError[version='#{Settings.api_version}'][generator='OpenStreetMap server']", 1
1237       assert_select "osmError>status", 1
1238       assert_select "osmError>message", 1
1239     end
1240
1241     ##
1242     # when we make some simple changes we get the same changes back from the
1243     # diff download.
1244     def test_diff_download_simple
1245       node = create(:node)
1246
1247       ## First try with a non-public user, which should get a forbidden
1248       basic_authorization create(:user, :data_public => false).email, "test"
1249
1250       # create a temporary changeset
1251       xml = "<osm><changeset>" \
1252             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1253             "</changeset></osm>"
1254       put :create, :body => xml
1255       assert_response :forbidden
1256
1257       ## Now try with a normal user
1258       basic_authorization create(:user).email, "test"
1259
1260       # create a temporary changeset
1261       xml = "<osm><changeset>" \
1262             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1263             "</changeset></osm>"
1264       put :create, :body => xml
1265       assert_response :success
1266       changeset_id = @response.body.to_i
1267
1268       # add a diff to it
1269       diff = <<~CHANGESET
1270         <osmChange>
1271          <modify>
1272           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
1273           <node id='#{node.id}' lon='1' lat='0' changeset='#{changeset_id}' version='2'/>
1274           <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset_id}' version='3'/>
1275           <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset_id}' version='4'/>
1276           <node id='#{node.id}' lon='2' lat='2' changeset='#{changeset_id}' version='5'/>
1277           <node id='#{node.id}' lon='3' lat='2' changeset='#{changeset_id}' version='6'/>
1278           <node id='#{node.id}' lon='3' lat='3' changeset='#{changeset_id}' version='7'/>
1279           <node id='#{node.id}' lon='9' lat='9' changeset='#{changeset_id}' version='8'/>
1280          </modify>
1281         </osmChange>
1282       CHANGESET
1283
1284       # upload it
1285       post :upload, :params => { :id => changeset_id }, :body => diff
1286       assert_response :success,
1287                       "can't upload multiple versions of an element in a diff: #{@response.body}"
1288
1289       get :download, :params => { :id => changeset_id }
1290       assert_response :success
1291
1292       assert_select "osmChange", 1
1293       assert_select "osmChange>modify", 8
1294       assert_select "osmChange>modify>node", 8
1295     end
1296
1297     ##
1298     # culled this from josm to ensure that nothing in the way that josm
1299     # is formatting the request is causing it to fail.
1300     #
1301     # NOTE: the error turned out to be something else completely!
1302     def test_josm_upload
1303       basic_authorization create(:user).email, "test"
1304
1305       # create a temporary changeset
1306       xml = "<osm><changeset>" \
1307             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1308             "</changeset></osm>"
1309       put :create, :body => xml
1310       assert_response :success
1311       changeset_id = @response.body.to_i
1312
1313       diff = <<~OSMFILE
1314         <osmChange version="0.6" generator="JOSM">
1315         <create version="0.6" generator="JOSM">
1316           <node id='-1' visible='true' changeset='#{changeset_id}' lat='51.49619982187321' lon='-0.18722061869438314' />
1317           <node id='-2' visible='true' changeset='#{changeset_id}' lat='51.496359883909605' lon='-0.18653093576241928' />
1318           <node id='-3' visible='true' changeset='#{changeset_id}' lat='51.49598132358285' lon='-0.18719613290981638' />
1319           <node id='-4' visible='true' changeset='#{changeset_id}' lat='51.4961591711078' lon='-0.18629015888084607' />
1320           <node id='-5' visible='true' changeset='#{changeset_id}' lat='51.49582126021711' lon='-0.18708186591517145' />
1321           <node id='-6' visible='true' changeset='#{changeset_id}' lat='51.49591018437858' lon='-0.1861432441734455' />
1322           <node id='-7' visible='true' changeset='#{changeset_id}' lat='51.49560784152179' lon='-0.18694719410005425' />
1323           <node id='-8' visible='true' changeset='#{changeset_id}' lat='51.49567389979617' lon='-0.1860289771788006' />
1324           <node id='-9' visible='true' changeset='#{changeset_id}' lat='51.49543761398892' lon='-0.186820684213126' />
1325           <way id='-10' action='modiy' visible='true' changeset='#{changeset_id}'>
1326             <nd ref='-1' />
1327             <nd ref='-2' />
1328             <nd ref='-3' />
1329             <nd ref='-4' />
1330             <nd ref='-5' />
1331             <nd ref='-6' />
1332             <nd ref='-7' />
1333             <nd ref='-8' />
1334             <nd ref='-9' />
1335             <tag k='highway' v='residential' />
1336             <tag k='name' v='Foobar Street' />
1337           </way>
1338         </create>
1339         </osmChange>
1340       OSMFILE
1341
1342       # upload it
1343       post :upload, :params => { :id => changeset_id }, :body => diff
1344       assert_response :success,
1345                       "can't upload a diff from JOSM: #{@response.body}"
1346
1347       get :download, :params => { :id => changeset_id }
1348       assert_response :success
1349
1350       assert_select "osmChange", 1
1351       assert_select "osmChange>create>node", 9
1352       assert_select "osmChange>create>way", 1
1353       assert_select "osmChange>create>way>nd", 9
1354       assert_select "osmChange>create>way>tag", 2
1355     end
1356
1357     ##
1358     # when we make some complex changes we get the same changes back from the
1359     # diff download.
1360     def test_diff_download_complex
1361       node = create(:node)
1362       node2 = create(:node)
1363       way = create(:way)
1364       basic_authorization create(:user).email, "test"
1365
1366       # create a temporary changeset
1367       xml = "<osm><changeset>" \
1368             "<tag k='created_by' v='osm test suite checking changesets'/>" \
1369             "</changeset></osm>"
1370       put :create, :body => xml
1371       assert_response :success
1372       changeset_id = @response.body.to_i
1373
1374       # add a diff to it
1375       diff = <<~CHANGESET
1376         <osmChange>
1377          <delete>
1378           <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
1379          </delete>
1380          <create>
1381           <node id='-1' lon='9' lat='9' changeset='#{changeset_id}' version='0'/>
1382           <node id='-2' lon='8' lat='9' changeset='#{changeset_id}' version='0'/>
1383           <node id='-3' lon='7' lat='9' changeset='#{changeset_id}' version='0'/>
1384          </create>
1385          <modify>
1386           <node id='#{node2.id}' lon='20' lat='15' changeset='#{changeset_id}' version='1'/>
1387           <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
1388            <nd ref='#{node2.id}'/>
1389            <nd ref='-1'/>
1390            <nd ref='-2'/>
1391            <nd ref='-3'/>
1392           </way>
1393          </modify>
1394         </osmChange>
1395       CHANGESET
1396
1397       # upload it
1398       post :upload, :params => { :id => changeset_id }, :body => diff
1399       assert_response :success,
1400                       "can't upload multiple versions of an element in a diff: #{@response.body}"
1401
1402       get :download, :params => { :id => changeset_id }
1403       assert_response :success
1404
1405       assert_select "osmChange", 1
1406       assert_select "osmChange>create", 3
1407       assert_select "osmChange>delete", 1
1408       assert_select "osmChange>modify", 2
1409       assert_select "osmChange>create>node", 3
1410       assert_select "osmChange>delete>node", 1
1411       assert_select "osmChange>modify>node", 1
1412       assert_select "osmChange>modify>way", 1
1413     end
1414
1415     def test_changeset_download
1416       changeset = create(:changeset)
1417       node = create(:node, :with_history, :version => 1, :changeset => changeset)
1418       tag = create(:old_node_tag, :old_node => node.old_nodes.find_by(:version => 1))
1419       node2 = create(:node, :with_history, :version => 1, :changeset => changeset)
1420       _node3 = create(:node, :with_history, :deleted, :version => 1, :changeset => changeset)
1421       _relation = create(:relation, :with_history, :version => 1, :changeset => changeset)
1422       _relation2 = create(:relation, :with_history, :deleted, :version => 1, :changeset => changeset)
1423
1424       get :download, :params => { :id => changeset.id }
1425
1426       assert_response :success
1427       assert_template nil
1428       # print @response.body
1429       # FIXME: needs more assert_select tests
1430       assert_select "osmChange[version='#{Settings.api_version}'][generator='#{Settings.generator}']" do
1431         assert_select "create", :count => 5
1432         assert_select "create>node[id='#{node.id}'][visible='#{node.visible?}'][version='#{node.version}']" do
1433           assert_select "tag[k='#{tag.k}'][v='#{tag.v}']"
1434         end
1435         assert_select "create>node[id='#{node2.id}']"
1436       end
1437     end
1438
1439     ##
1440     # check that the bounding box of a changeset gets updated correctly
1441     # FIXME: This should really be moded to a integration test due to the with_controller
1442     def test_changeset_bbox
1443       way = create(:way)
1444       create(:way_node, :way => way, :node => create(:node, :lat => 3, :lon => 3))
1445
1446       basic_authorization create(:user).email, "test"
1447
1448       # create a new changeset
1449       xml = "<osm><changeset/></osm>"
1450       put :create, :body => xml
1451       assert_response :success, "Creating of changeset failed."
1452       changeset_id = @response.body.to_i
1453
1454       # add a single node to it
1455       with_controller(NodesController.new) do
1456         xml = "<osm><node lon='1' lat='2' changeset='#{changeset_id}'/></osm>"
1457         put :create, :body => xml
1458         assert_response :success, "Couldn't create node."
1459       end
1460
1461       # get the bounding box back from the changeset
1462       get :show, :params => { :id => changeset_id }
1463       assert_response :success, "Couldn't read back changeset."
1464       assert_select "osm>changeset[min_lon='1.0000000']", 1
1465       assert_select "osm>changeset[max_lon='1.0000000']", 1
1466       assert_select "osm>changeset[min_lat='2.0000000']", 1
1467       assert_select "osm>changeset[max_lat='2.0000000']", 1
1468
1469       # add another node to it
1470       with_controller(NodesController.new) do
1471         xml = "<osm><node lon='2' lat='1' changeset='#{changeset_id}'/></osm>"
1472         put :create, :body => xml
1473         assert_response :success, "Couldn't create second node."
1474       end
1475
1476       # get the bounding box back from the changeset
1477       get :show, :params => { :id => changeset_id }
1478       assert_response :success, "Couldn't read back changeset for the second time."
1479       assert_select "osm>changeset[min_lon='1.0000000']", 1
1480       assert_select "osm>changeset[max_lon='2.0000000']", 1
1481       assert_select "osm>changeset[min_lat='1.0000000']", 1
1482       assert_select "osm>changeset[max_lat='2.0000000']", 1
1483
1484       # add (delete) a way to it, which contains a point at (3,3)
1485       with_controller(WaysController.new) do
1486         xml = update_changeset(xml_for_way(way), changeset_id)
1487         put :delete, :params => { :id => way.id }, :body => xml.to_s
1488         assert_response :success, "Couldn't delete a way."
1489       end
1490
1491       # get the bounding box back from the changeset
1492       get :show, :params => { :id => changeset_id }
1493       assert_response :success, "Couldn't read back changeset for the third time."
1494       assert_select "osm>changeset[min_lon='1.0000000']", 1
1495       assert_select "osm>changeset[max_lon='3.0000000']", 1
1496       assert_select "osm>changeset[min_lat='1.0000000']", 1
1497       assert_select "osm>changeset[max_lat='3.0000000']", 1
1498     end
1499
1500     ##
1501     # test the query functionality of changesets
1502     def test_query
1503       private_user = create(:user, :data_public => false)
1504       private_user_changeset = create(:changeset, :user => private_user)
1505       private_user_closed_changeset = create(:changeset, :closed, :user => private_user)
1506       user = create(:user)
1507       changeset = create(:changeset, :user => user)
1508       closed_changeset = create(:changeset, :closed, :user => user, :created_at => Time.utc(2008, 1, 1, 0, 0, 0), :closed_at => Time.utc(2008, 1, 2, 0, 0, 0))
1509       changeset2 = create(:changeset, :min_lat => (5 * GeoRecord::SCALE).round, :min_lon => (5 * GeoRecord::SCALE).round, :max_lat => (15 * GeoRecord::SCALE).round, :max_lon => (15 * GeoRecord::SCALE).round)
1510       changeset3 = create(:changeset, :min_lat => (4.5 * GeoRecord::SCALE).round, :min_lon => (4.5 * GeoRecord::SCALE).round, :max_lat => (5 * GeoRecord::SCALE).round, :max_lon => (5 * GeoRecord::SCALE).round)
1511
1512       get :query, :params => { :bbox => "-10,-10, 10, 10" }
1513       assert_response :success, "can't get changesets in bbox"
1514       assert_changesets [changeset2, changeset3]
1515
1516       get :query, :params => { :bbox => "4.5,4.5,4.6,4.6" }
1517       assert_response :success, "can't get changesets in bbox"
1518       assert_changesets [changeset3]
1519
1520       # not found when looking for changesets of non-existing users
1521       get :query, :params => { :user => User.maximum(:id) + 1 }
1522       assert_response :not_found
1523       get :query, :params => { :display_name => " " }
1524       assert_response :not_found
1525
1526       # can't get changesets of user 1 without authenticating
1527       get :query, :params => { :user => private_user.id }
1528       assert_response :not_found, "shouldn't be able to get changesets by non-public user (ID)"
1529       get :query, :params => { :display_name => private_user.display_name }
1530       assert_response :not_found, "shouldn't be able to get changesets by non-public user (name)"
1531
1532       # but this should work
1533       basic_authorization private_user.email, "test"
1534       get :query, :params => { :user => private_user.id }
1535       assert_response :success, "can't get changesets by user ID"
1536       assert_changesets [private_user_changeset, private_user_closed_changeset]
1537
1538       get :query, :params => { :display_name => private_user.display_name }
1539       assert_response :success, "can't get changesets by user name"
1540       assert_changesets [private_user_changeset, private_user_closed_changeset]
1541
1542       # check that the correct error is given when we provide both UID and name
1543       get :query, :params => { :user => private_user.id,
1544                                :display_name => private_user.display_name }
1545       assert_response :bad_request, "should be a bad request to have both ID and name specified"
1546
1547       get :query, :params => { :user => private_user.id, :open => true }
1548       assert_response :success, "can't get changesets by user and open"
1549       assert_changesets [private_user_changeset]
1550
1551       get :query, :params => { :time => "2007-12-31" }
1552       assert_response :success, "can't get changesets by time-since"
1553       assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3]
1554
1555       get :query, :params => { :time => "2008-01-01T12:34Z" }
1556       assert_response :success, "can't get changesets by time-since with hour"
1557       assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3]
1558
1559       get :query, :params => { :time => "2007-12-31T23:59Z,2008-01-02T00:01Z" }
1560       assert_response :success, "can't get changesets by time-range"
1561       assert_changesets [closed_changeset]
1562
1563       get :query, :params => { :open => "true" }
1564       assert_response :success, "can't get changesets by open-ness"
1565       assert_changesets [private_user_changeset, changeset, changeset2, changeset3]
1566
1567       get :query, :params => { :closed => "true" }
1568       assert_response :success, "can't get changesets by closed-ness"
1569       assert_changesets [private_user_closed_changeset, closed_changeset]
1570
1571       get :query, :params => { :closed => "true", :user => private_user.id }
1572       assert_response :success, "can't get changesets by closed-ness and user"
1573       assert_changesets [private_user_closed_changeset]
1574
1575       get :query, :params => { :closed => "true", :user => user.id }
1576       assert_response :success, "can't get changesets by closed-ness and user"
1577       assert_changesets [closed_changeset]
1578
1579       get :query, :params => { :changesets => "#{private_user_changeset.id},#{changeset.id},#{closed_changeset.id}" }
1580       assert_response :success, "can't get changesets by id (as comma-separated string)"
1581       assert_changesets [private_user_changeset, changeset, closed_changeset]
1582
1583       get :query, :params => { :changesets => "" }
1584       assert_response :bad_request, "should be a bad request since changesets is empty"
1585     end
1586
1587     ##
1588     # check that errors are returned if garbage is inserted
1589     # into query strings
1590     def test_query_invalid
1591       ["abracadabra!",
1592        "1,2,3,F",
1593        ";drop table users;"].each do |bbox|
1594         get :query, :params => { :bbox => bbox }
1595         assert_response :bad_request, "'#{bbox}' isn't a bbox"
1596       end
1597
1598       ["now()",
1599        "00-00-00",
1600        ";drop table users;",
1601        ",",
1602        "-,-"].each do |time|
1603         get :query, :params => { :time => time }
1604         assert_response :bad_request, "'#{time}' isn't a valid time range"
1605       end
1606
1607       ["me",
1608        "foobar",
1609        "-1",
1610        "0"].each do |uid|
1611         get :query, :params => { :user => uid }
1612         assert_response :bad_request, "'#{uid}' isn't a valid user ID"
1613       end
1614     end
1615
1616     ##
1617     # check updating tags on a changeset
1618     def test_changeset_update
1619       private_user = create(:user, :data_public => false)
1620       private_changeset = create(:changeset, :user => private_user)
1621       user = create(:user)
1622       changeset = create(:changeset, :user => user)
1623
1624       ## First try with a non-public user
1625       new_changeset = create_changeset_xml(:user => private_user)
1626       new_tag = XML::Node.new "tag"
1627       new_tag["k"] = "tagtesting"
1628       new_tag["v"] = "valuetesting"
1629       new_changeset.find("//osm/changeset").first << new_tag
1630
1631       # try without any authorization
1632       put :update, :params => { :id => private_changeset.id }, :body => new_changeset.to_s
1633       assert_response :unauthorized
1634
1635       # try with the wrong authorization
1636       basic_authorization create(:user).email, "test"
1637       put :update, :params => { :id => private_changeset.id }, :body => new_changeset.to_s
1638       assert_response :conflict
1639
1640       # now this should get an unauthorized
1641       basic_authorization private_user.email, "test"
1642       put :update, :params => { :id => private_changeset.id }, :body => new_changeset.to_s
1643       assert_require_public_data "user with their data non-public, shouldn't be able to edit their changeset"
1644
1645       ## Now try with the public user
1646       new_changeset = create_changeset_xml(:id => 1)
1647       new_tag = XML::Node.new "tag"
1648       new_tag["k"] = "tagtesting"
1649       new_tag["v"] = "valuetesting"
1650       new_changeset.find("//osm/changeset").first << new_tag
1651
1652       # try without any authorization
1653       @request.env["HTTP_AUTHORIZATION"] = nil
1654       put :update, :params => { :id => changeset.id }, :body => new_changeset.to_s
1655       assert_response :unauthorized
1656
1657       # try with the wrong authorization
1658       basic_authorization create(:user).email, "test"
1659       put :update, :params => { :id => changeset.id }, :body => new_changeset.to_s
1660       assert_response :conflict
1661
1662       # now this should work...
1663       basic_authorization user.email, "test"
1664       put :update, :params => { :id => changeset.id }, :body => new_changeset.to_s
1665       assert_response :success
1666
1667       assert_select "osm>changeset[id='#{changeset.id}']", 1
1668       assert_select "osm>changeset>tag", 1
1669       assert_select "osm>changeset>tag[k='tagtesting'][v='valuetesting']", 1
1670     end
1671
1672     ##
1673     # check that a user different from the one who opened the changeset
1674     # can't modify it.
1675     def test_changeset_update_invalid
1676       basic_authorization create(:user).email, "test"
1677
1678       changeset = create(:changeset)
1679       new_changeset = create_changeset_xml(:user => changeset.user, :id => changeset.id)
1680       new_tag = XML::Node.new "tag"
1681       new_tag["k"] = "testing"
1682       new_tag["v"] = "testing"
1683       new_changeset.find("//osm/changeset").first << new_tag
1684
1685       put :update, :params => { :id => changeset.id }, :body => new_changeset.to_s
1686       assert_response :conflict
1687     end
1688
1689     ##
1690     # check that a changeset can contain a certain max number of changes.
1691     ## FIXME should be changed to an integration test due to the with_controller
1692     def test_changeset_limits
1693       basic_authorization create(:user).email, "test"
1694
1695       # open a new changeset
1696       xml = "<osm><changeset/></osm>"
1697       put :create, :body => xml
1698       assert_response :success, "can't create a new changeset"
1699       cs_id = @response.body.to_i
1700
1701       # start the counter just short of where the changeset should finish.
1702       offset = 10
1703       # alter the database to set the counter on the changeset directly,
1704       # otherwise it takes about 6 minutes to fill all of them.
1705       changeset = Changeset.find(cs_id)
1706       changeset.num_changes = Changeset::MAX_ELEMENTS - offset
1707       changeset.save!
1708
1709       with_controller(NodesController.new) do
1710         # create a new node
1711         xml = "<osm><node changeset='#{cs_id}' lat='0.0' lon='0.0'/></osm>"
1712         put :create, :body => xml
1713         assert_response :success, "can't create a new node"
1714         node_id = @response.body.to_i
1715
1716         get :show, :params => { :id => node_id }
1717         assert_response :success, "can't read back new node"
1718         node_doc = XML::Parser.string(@response.body).parse
1719         node_xml = node_doc.find("//osm/node").first
1720
1721         # loop until we fill the changeset with nodes
1722         offset.times do |i|
1723           node_xml["lat"] = rand.to_s
1724           node_xml["lon"] = rand.to_s
1725           node_xml["version"] = (i + 1).to_s
1726
1727           put :update, :params => { :id => node_id }, :body => node_doc.to_s
1728           assert_response :success, "attempt #{i} should have succeeded"
1729         end
1730
1731         # trying again should fail
1732         node_xml["lat"] = rand.to_s
1733         node_xml["lon"] = rand.to_s
1734         node_xml["version"] = offset.to_s
1735
1736         put :update, :params => { :id => node_id }, :body => node_doc.to_s
1737         assert_response :conflict, "final attempt should have failed"
1738       end
1739
1740       changeset = Changeset.find(cs_id)
1741       assert_equal Changeset::MAX_ELEMENTS + 1, changeset.num_changes
1742
1743       # check that the changeset is now closed as well
1744       assert_not(changeset.is_open?,
1745                  "changeset should have been auto-closed by exceeding " \
1746                  "element limit.")
1747     end
1748
1749     ##
1750     # check that the changeset download for a changeset with a redacted
1751     # element in it doesn't contain that element.
1752     def test_diff_download_redacted
1753       changeset = create(:changeset)
1754       node = create(:node, :with_history, :version => 2, :changeset => changeset)
1755       node_v1 = node.old_nodes.find_by(:version => 1)
1756       node_v1.redact!(create(:redaction))
1757
1758       get :download, :params => { :id => changeset.id }
1759       assert_response :success
1760
1761       assert_select "osmChange", 1
1762       # this changeset contains the node in versions 1 & 2, but 1 should
1763       # be hidden.
1764       assert_select "osmChange node[id='#{node.id}']", 1
1765       assert_select "osmChange node[id='#{node.id}'][version='1']", 0
1766     end
1767
1768     ##
1769     # test subscribe success
1770     def test_subscribe_success
1771       basic_authorization create(:user).email, "test"
1772       changeset = create(:changeset, :closed)
1773
1774       assert_difference "changeset.subscribers.count", 1 do
1775         post :subscribe, :params => { :id => changeset.id }
1776       end
1777       assert_response :success
1778
1779       # not closed changeset
1780       changeset = create(:changeset)
1781       assert_difference "changeset.subscribers.count", 1 do
1782         post :subscribe, :params => { :id => changeset.id }
1783       end
1784       assert_response :success
1785     end
1786
1787     ##
1788     # test subscribe fail
1789     def test_subscribe_fail
1790       user = create(:user)
1791
1792       # unauthorized
1793       changeset = create(:changeset, :closed)
1794       assert_no_difference "changeset.subscribers.count" do
1795         post :subscribe, :params => { :id => changeset.id }
1796       end
1797       assert_response :unauthorized
1798
1799       basic_authorization user.email, "test"
1800
1801       # bad changeset id
1802       assert_no_difference "changeset.subscribers.count" do
1803         post :subscribe, :params => { :id => 999111 }
1804       end
1805       assert_response :not_found
1806
1807       # trying to subscribe when already subscribed
1808       changeset = create(:changeset, :closed)
1809       changeset.subscribers.push(user)
1810       assert_no_difference "changeset.subscribers.count" do
1811         post :subscribe, :params => { :id => changeset.id }
1812       end
1813       assert_response :conflict
1814     end
1815
1816     ##
1817     # test unsubscribe success
1818     def test_unsubscribe_success
1819       user = create(:user)
1820       basic_authorization user.email, "test"
1821       changeset = create(:changeset, :closed)
1822       changeset.subscribers.push(user)
1823
1824       assert_difference "changeset.subscribers.count", -1 do
1825         post :unsubscribe, :params => { :id => changeset.id }
1826       end
1827       assert_response :success
1828
1829       # not closed changeset
1830       changeset = create(:changeset)
1831       changeset.subscribers.push(user)
1832
1833       assert_difference "changeset.subscribers.count", -1 do
1834         post :unsubscribe, :params => { :id => changeset.id }
1835       end
1836       assert_response :success
1837     end
1838
1839     ##
1840     # test unsubscribe fail
1841     def test_unsubscribe_fail
1842       # unauthorized
1843       changeset = create(:changeset, :closed)
1844       assert_no_difference "changeset.subscribers.count" do
1845         post :unsubscribe, :params => { :id => changeset.id }
1846       end
1847       assert_response :unauthorized
1848
1849       basic_authorization create(:user).email, "test"
1850
1851       # bad changeset id
1852       assert_no_difference "changeset.subscribers.count" do
1853         post :unsubscribe, :params => { :id => 999111 }
1854       end
1855       assert_response :not_found
1856
1857       # trying to unsubscribe when not subscribed
1858       changeset = create(:changeset, :closed)
1859       assert_no_difference "changeset.subscribers.count" do
1860         post :unsubscribe, :params => { :id => changeset.id }
1861       end
1862       assert_response :not_found
1863     end
1864
1865     private
1866
1867     ##
1868     # boilerplate for checking that certain changesets exist in the
1869     # output.
1870     def assert_changesets(changesets)
1871       assert_select "osm>changeset", changesets.size
1872       changesets.each do |changeset|
1873         assert_select "osm>changeset[id='#{changeset.id}']", 1
1874       end
1875     end
1876
1877     ##
1878     # update the changeset_id of a way element
1879     def update_changeset(xml, changeset_id)
1880       xml_attr_rewrite(xml, "changeset", changeset_id)
1881     end
1882
1883     ##
1884     # update an attribute in a way element
1885     def xml_attr_rewrite(xml, name, value)
1886       xml.find("//osm/way").first[name] = value.to_s
1887       xml
1888     end
1889
1890     ##
1891     # build XML for changesets
1892     def create_changeset_xml(user: nil, id: nil)
1893       root = XML::Document.new
1894       root.root = XML::Node.new "osm"
1895       cs = XML::Node.new "changeset"
1896       if user
1897         cs["user"] = user.display_name
1898         cs["uid"] = user.id.to_s
1899       end
1900       cs["id"] = id.to_s if id
1901       root.root << cs
1902       root
1903     end
1904   end
1905 end