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