4 class OldNodesControllerTest < ActionDispatch::IntegrationTest
10 # test all routes which lead to this controller
13 { :path => "/api/0.6/node/1/history", :method => :get },
14 { :controller => "api/old_nodes", :action => "history", :id => "1" }
17 { :path => "/api/0.6/node/1/2", :method => :get },
18 { :controller => "api/old_nodes", :action => "version", :id => "1", :version => "2" }
21 { :path => "/api/0.6/node/1/history.json", :method => :get },
22 { :controller => "api/old_nodes", :action => "history", :id => "1", :format => "json" }
25 { :path => "/api/0.6/node/1/2.json", :method => :get },
26 { :controller => "api/old_nodes", :action => "version", :id => "1", :version => "2", :format => "json" }
29 { :path => "/api/0.6/node/1/2/redact", :method => :post },
30 { :controller => "api/old_nodes", :action => "redact", :id => "1", :version => "2" }
35 # test the version call by submitting several revisions of a new node
36 # to the API and ensuring that later calls to version return the
37 # matching versions of the object.
40 # FIXME: Move this test to being an integration test since it spans multiple controllers
42 private_user = create(:user, :data_public => false)
43 private_node = create(:node, :with_history, :version => 4, :changeset => create(:changeset, :user => private_user))
45 node = create(:node, :with_history, :version => 4, :changeset => create(:changeset, :user => user))
46 create_list(:node_tag, 2, :node => node)
47 # Ensure that the current tags are propagated to the history too
48 propagate_tags(node, node.old_nodes.last)
50 ## First try this with a non-public user
51 auth_header = basic_authorization_header private_user.email, "test"
53 # setup a simple XML node
54 xml_doc = xml_for_node(private_node)
55 xml_node = xml_doc.find("//osm/node").first
56 nodeid = private_node.id
58 # keep a hash of the versions => string, as we'll need something
59 # to test against later
62 # save a version for later checking
63 versions[xml_node["version"]] = xml_doc.to_s
65 # randomly move the node about
67 # move the node somewhere else
68 xml_node["lat"] = precision(rand * 180 - 90).to_s
69 xml_node["lon"] = precision(rand * 360 - 180).to_s
70 with_controller(NodesController.new) do
71 put api_node_path(:id => nodeid), :params => xml_doc.to_s, :headers => auth_header
72 assert_response :forbidden, "Should have rejected node update"
73 xml_node["version"] = @response.body.to_s
75 # save a version for later checking
76 versions[xml_node["version"]] = xml_doc.to_s
79 # add a bunch of random tags
81 xml_tag = XML::Node.new("tag")
82 xml_tag["k"] = random_string
83 xml_tag["v"] = random_string
85 with_controller(NodesController.new) do
86 put api_node_path(:id => nodeid), :params => xml_doc.to_s, :headers => auth_header
87 assert_response :forbidden,
88 "should have rejected node #{nodeid} (#{@response.body}) with forbidden"
89 xml_node["version"] = @response.body.to_s
91 # save a version for later checking
92 versions[xml_node["version"]] = xml_doc.to_s
95 # probably should check that they didn't get written to the database
97 ## Now do it with the public user
98 auth_header = basic_authorization_header user.email, "test"
100 # setup a simple XML node
102 xml_doc = xml_for_node(node)
103 xml_node = xml_doc.find("//osm/node").first
106 # keep a hash of the versions => string, as we'll need something
107 # to test against later
110 # save a version for later checking
111 versions[xml_node["version"]] = xml_doc.to_s
113 # randomly move the node about
115 # move the node somewhere else
116 xml_node["lat"] = precision(rand * 180 - 90).to_s
117 xml_node["lon"] = precision(rand * 360 - 180).to_s
118 with_controller(NodesController.new) do
119 put api_node_path(:id => nodeid), :params => xml_doc.to_s, :headers => auth_header
120 assert_response :success
121 xml_node["version"] = @response.body.to_s
123 # save a version for later checking
124 versions[xml_node["version"]] = xml_doc.to_s
127 # add a bunch of random tags
129 xml_tag = XML::Node.new("tag")
130 xml_tag["k"] = random_string
131 xml_tag["v"] = random_string
133 with_controller(NodesController.new) do
134 put api_node_path(:id => nodeid), :params => xml_doc.to_s, :headers => auth_header
135 assert_response :success,
136 "couldn't update node #{nodeid} (#{@response.body})"
137 xml_node["version"] = @response.body.to_s
139 # save a version for later checking
140 versions[xml_node["version"]] = xml_doc.to_s
143 # check all the versions
144 versions.each_key do |key|
145 get node_version_path(:id => nodeid, :version => key.to_i)
147 assert_response :success,
148 "couldn't get version #{key.to_i} of node #{nodeid}"
150 check_node = Node.from_xml(versions[key])
151 api_node = Node.from_xml(@response.body.to_s)
153 assert_nodes_are_equal check_node, api_node
157 def test_not_found_version
158 check_not_found_id_version(70000, 312344)
159 check_not_found_id_version(-1, -13)
160 check_not_found_id_version(create(:node).id, 24354)
161 check_not_found_id_version(24356, create(:node).version)
165 # Test that getting the current version is identical to picking
166 # that version with the version URI call.
167 def test_current_version
168 node = create(:node, :with_history)
169 used_node = create(:node, :with_history)
170 create(:way_node, :node => used_node)
171 node_used_by_relationship = create(:node, :with_history)
172 create(:relation_member, :member => node_used_by_relationship)
173 node_with_versions = create(:node, :with_history, :version => 4)
175 create(:node_tag, :node => node)
176 create(:node_tag, :node => used_node)
177 create(:node_tag, :node => node_used_by_relationship)
178 create(:node_tag, :node => node_with_versions)
179 propagate_tags(node, node.old_nodes.last)
180 propagate_tags(used_node, used_node.old_nodes.last)
181 propagate_tags(node_used_by_relationship, node_used_by_relationship.old_nodes.last)
182 propagate_tags(node_with_versions, node_with_versions.old_nodes.last)
184 check_current_version(node)
185 check_current_version(used_node)
186 check_current_version(node_used_by_relationship)
187 check_current_version(node_with_versions)
191 # test the redaction of an old version of a node, while not being
193 def test_redact_node_unauthorised
194 node = create(:node, :with_history, :version => 4)
195 node_v3 = node.old_nodes.find_by(:version => 3)
197 do_redact_node(node_v3,
199 assert_response :unauthorized, "should need to be authenticated to redact."
203 # test the redaction of an old version of a node, while being
204 # authorised as a normal user.
205 def test_redact_node_normal_user
206 auth_header = basic_authorization_header create(:user).email, "test"
208 node = create(:node, :with_history, :version => 4)
209 node_v3 = node.old_nodes.find_by(:version => 3)
211 do_redact_node(node_v3,
214 assert_response :forbidden, "should need to be moderator to redact."
218 # test that, even as moderator, the current version of a node
220 def test_redact_node_current_version
221 auth_header = basic_authorization_header create(:moderator_user).email, "test"
223 node = create(:node, :with_history, :version => 4)
224 node_v4 = node.old_nodes.find_by(:version => 4)
226 do_redact_node(node_v4,
229 assert_response :bad_request, "shouldn't be OK to redact current version as moderator."
233 # test that redacted nodes aren't visible, regardless of
234 # authorisation except as moderator...
235 def test_version_redacted
236 node = create(:node, :with_history, :version => 2)
237 node_v1 = node.old_nodes.find_by(:version => 1)
238 node_v1.redact!(create(:redaction))
240 get node_version_path(:id => node_v1.node_id, :version => node_v1.version)
241 assert_response :forbidden, "Redacted node shouldn't be visible via the version API."
243 # not even to a logged-in user
244 auth_header = basic_authorization_header create(:user).email, "test"
245 get node_version_path(:id => node_v1.node_id, :version => node_v1.version), :headers => auth_header
246 assert_response :forbidden, "Redacted node shouldn't be visible via the version API, even when logged in."
250 # test that redacted nodes aren't visible in the history
251 def test_history_redacted
252 node = create(:node, :with_history, :version => 2)
253 node_v1 = node.old_nodes.find_by(:version => 1)
254 node_v1.redact!(create(:redaction))
256 get api_node_history_path(:id => node_v1.node_id)
257 assert_response :success, "Redaction shouldn't have stopped history working."
258 assert_select "osm node[id='#{node_v1.node_id}'][version='#{node_v1.version}']", 0, "redacted node #{node_v1.node_id} version #{node_v1.version} shouldn't be present in the history."
260 # not even to a logged-in user
261 auth_header = basic_authorization_header create(:user).email, "test"
262 get api_node_history_path(:id => node_v1.node_id), :headers => auth_header
263 assert_response :success, "Redaction shouldn't have stopped history working."
264 assert_select "osm node[id='#{node_v1.node_id}'][version='#{node_v1.version}']", 0, "redacted node #{node_v1.node_id} version #{node_v1.version} shouldn't be present in the history, even when logged in."
268 # test the redaction of an old version of a node, while being
269 # authorised as a moderator.
270 def test_redact_node_moderator
271 node = create(:node, :with_history, :version => 4)
272 node_v3 = node.old_nodes.find_by(:version => 3)
273 auth_header = basic_authorization_header create(:moderator_user).email, "test"
275 do_redact_node(node_v3, create(:redaction), auth_header)
276 assert_response :success, "should be OK to redact old version as moderator."
278 # check moderator can still see the redacted data, when passing
279 # the appropriate flag
280 get node_version_path(:id => node_v3.node_id, :version => node_v3.version), :headers => auth_header
281 assert_response :forbidden, "After redaction, node should be gone for moderator, when flag not passed."
282 get node_version_path(:id => node_v3.node_id, :version => node_v3.version), :params => { :show_redactions => "true" }, :headers => auth_header
283 assert_response :success, "After redaction, node should not be gone for moderator, when flag passed."
285 # and when accessed via history
286 get api_node_history_path(:id => node_v3.node_id)
287 assert_response :success, "Redaction shouldn't have stopped history working."
288 assert_select "osm node[id='#{node_v3.node_id}'][version='#{node_v3.version}']", 0, "node #{node_v3.node_id} version #{node_v3.version} should not be present in the history for moderators when not passing flag."
289 get api_node_history_path(:id => node_v3.node_id), :params => { :show_redactions => "true" }, :headers => auth_header
290 assert_response :success, "Redaction shouldn't have stopped history working."
291 assert_select "osm node[id='#{node_v3.node_id}'][version='#{node_v3.version}']", 1, "node #{node_v3.node_id} version #{node_v3.version} should still be present in the history for moderators when passing flag."
294 # testing that if the moderator drops auth, he can't see the
295 # redacted stuff any more.
296 def test_redact_node_is_redacted
297 node = create(:node, :with_history, :version => 4)
298 node_v3 = node.old_nodes.find_by(:version => 3)
299 auth_header = basic_authorization_header create(:moderator_user).email, "test"
301 do_redact_node(node_v3, create(:redaction), auth_header)
302 assert_response :success, "should be OK to redact old version as moderator."
304 # re-auth as non-moderator
305 auth_header = basic_authorization_header create(:user).email, "test"
307 # check can't see the redacted data
308 get node_version_path(:id => node_v3.node_id, :version => node_v3.version), :headers => auth_header
309 assert_response :forbidden, "Redacted node shouldn't be visible via the version API."
311 # and when accessed via history
312 get api_node_history_path(:id => node_v3.node_id), :headers => auth_header
313 assert_response :success, "Redaction shouldn't have stopped history working."
314 assert_select "osm node[id='#{node_v3.node_id}'][version='#{node_v3.version}']", 0, "redacted node #{node_v3.node_id} version #{node_v3.version} shouldn't be present in the history."
318 # test the unredaction of an old version of a node, while not being
320 def test_unredact_node_unauthorised
321 node = create(:node, :with_history, :version => 2)
322 node_v1 = node.old_nodes.find_by(:version => 1)
323 node_v1.redact!(create(:redaction))
325 post node_version_redact_path(:id => node_v1.node_id, :version => node_v1.version)
326 assert_response :unauthorized, "should need to be authenticated to unredact."
330 # test the unredaction of an old version of a node, while being
331 # authorised as a normal user.
332 def test_unredact_node_normal_user
334 node = create(:node, :with_history, :version => 2)
335 node_v1 = node.old_nodes.find_by(:version => 1)
336 node_v1.redact!(create(:redaction))
338 auth_header = basic_authorization_header user.email, "test"
340 post node_version_redact_path(:id => node_v1.node_id, :version => node_v1.version), :headers => auth_header
341 assert_response :forbidden, "should need to be moderator to unredact."
345 # test the unredaction of an old version of a node, while being
346 # authorised as a moderator.
347 def test_unredact_node_moderator
348 moderator_user = create(:moderator_user)
349 node = create(:node, :with_history, :version => 2)
350 node_v1 = node.old_nodes.find_by(:version => 1)
351 node_v1.redact!(create(:redaction))
353 auth_header = basic_authorization_header moderator_user.email, "test"
355 post node_version_redact_path(:id => node_v1.node_id, :version => node_v1.version), :headers => auth_header
356 assert_response :success, "should be OK to unredact old version as moderator."
358 # check moderator can now see the redacted data, when not
359 # passing the aspecial flag
360 get node_version_path(:id => node_v1.node_id, :version => node_v1.version), :headers => auth_header
361 assert_response :success, "After unredaction, node should not be gone for moderator."
363 # and when accessed via history
364 get api_node_history_path(:id => node_v1.node_id)
365 assert_response :success, "Unredaction shouldn't have stopped history working."
366 assert_select "osm node[id='#{node_v1.node_id}'][version='#{node_v1.version}']", 1, "node #{node_v1.node_id} version #{node_v1.version} should now be present in the history for moderators without passing flag."
368 auth_header = basic_authorization_header create(:user).email, "test"
370 # check normal user can now see the redacted data
371 get node_version_path(:id => node_v1.node_id, :version => node_v1.version), :headers => auth_header
372 assert_response :success, "After unredaction, node should be visible to normal users."
374 # and when accessed via history
375 get api_node_history_path(:id => node_v1.node_id)
376 assert_response :success, "Unredaction shouldn't have stopped history working."
377 assert_select "osm node[id='#{node_v1.node_id}'][version='#{node_v1.version}']", 1, "node #{node_v1.node_id} version #{node_v1.version} should now be present in the history for normal users without passing flag."
382 def do_redact_node(node, redaction, headers = {})
383 get node_version_path(:id => node.node_id, :version => node.version), :headers => headers
384 assert_response :success, "should be able to get version #{node.version} of node #{node.node_id}."
387 post node_version_redact_path(:id => node.node_id, :version => node.version), :params => { :redaction => redaction.id }, :headers => headers
390 def check_current_version(node_id)
391 # get the current version of the node
392 current_node = with_controller(NodesController.new) do
393 get api_node_path(:id => node_id)
394 assert_response :success, "cant get current node #{node_id}"
395 Node.from_xml(@response.body)
397 assert_not_nil current_node, "getting node #{node_id} returned nil"
399 # get the "old" version of the node from the old_node interface
400 get node_version_path(:id => node_id, :version => current_node.version)
401 assert_response :success, "cant get old node #{node_id}, v#{current_node.version}"
402 old_node = Node.from_xml(@response.body)
404 # check the nodes are the same
405 assert_nodes_are_equal current_node, old_node
408 def check_not_found_id_version(id, version)
409 get node_version_path(:id => id, :version => version)
410 assert_response :not_found
411 rescue ActionController::UrlGenerationError => e
412 assert_match(/No route matches/, e.to_s)
416 # returns a 16 character long string with some nasty characters in it.
417 # this ought to stress-test the tag handling as well as the versioning.
419 letters = [["!", '"', "$", "&", ";", "@"],
422 ("0".."9").to_a].flatten
423 (1..16).map { |_i| letters[rand(letters.length)] }.join
427 # truncate a floating point number to the scale that it is stored in
428 # the database. otherwise rounding errors can produce failing unit
429 # tests when they shouldn't.
431 (f * GeoRecord::SCALE).round.to_f / GeoRecord::SCALE
434 def propagate_tags(node, old_node)
435 node.tags.each do |k, v|
436 create(:old_node_tag, :old_node => old_node, :k => k, :v => v)