X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/9a9b045372a6f48420a9a6dacfde52c34ab7abce..95abc14b305f03de27352a252a451d1e0b200a4d:/test/controllers/old_node_controller_test.rb

diff --git a/test/controllers/old_node_controller_test.rb b/test/controllers/old_node_controller_test.rb
index f2658b123..babb9df13 100644
--- a/test/controllers/old_node_controller_test.rb
+++ b/test/controllers/old_node_controller_test.rb
@@ -86,10 +86,14 @@ class OldNodeControllerTest < ActionController::TestCase
     basic_authorization(users(:public_user).email, "test")
 
     # setup a simple XML node
+    create_list(:node_tag, 2, :node => current_nodes(:node_with_versions))
     xml_doc = current_nodes(:node_with_versions).to_xml
     xml_node = xml_doc.find("//osm/node").first
     nodeid = current_nodes(:node_with_versions).id
 
+    # Ensure that the current tags are propagated to the history too
+    propagate_tags(current_nodes(:node_with_versions), nodes(:node_with_versions_v4))
+
     # keep a hash of the versions => string, as we'll need something
     # to test against later
     versions = {}
@@ -161,6 +165,17 @@ class OldNodeControllerTest < ActionController::TestCase
   # Test that getting the current version is identical to picking
   # that version with the version URI call.
   def test_current_version
+    create(:node_tag, :node => current_nodes(:visible_node))
+    create(:node_tag, :node => current_nodes(:used_node_1))
+    create(:node_tag, :node => current_nodes(:used_node_2))
+    create(:node_tag, :node => current_nodes(:node_used_by_relationship))
+    create(:node_tag, :node => current_nodes(:node_with_versions))
+    propagate_tags(current_nodes(:visible_node), nodes(:visible_node))
+    propagate_tags(current_nodes(:used_node_1), nodes(:used_node_1))
+    propagate_tags(current_nodes(:used_node_2), nodes(:used_node_2))
+    propagate_tags(current_nodes(:node_used_by_relationship), nodes(:node_used_by_relationship))
+    propagate_tags(current_nodes(:node_with_versions), nodes(:node_with_versions_v4))
+
     check_current_version(current_nodes(:visible_node))
     check_current_version(current_nodes(:used_node_1))
     check_current_version(current_nodes(:used_node_2))
@@ -173,7 +188,7 @@ class OldNodeControllerTest < ActionController::TestCase
   # authorised.
   def test_redact_node_unauthorised
     do_redact_node(nodes(:node_with_versions_v3),
-                   redactions(:example))
+                   create(:redaction))
     assert_response :unauthorized, "should need to be authenticated to redact."
   end
 
@@ -181,10 +196,10 @@ class OldNodeControllerTest < ActionController::TestCase
   # test the redaction of an old version of a node, while being
   # authorised as a normal user.
   def test_redact_node_normal_user
-    basic_authorization(users(:public_user).email, "test")
+    basic_authorization(create(:user).email, "test")
 
     do_redact_node(nodes(:node_with_versions_v3),
-                   redactions(:example))
+                   create(:redaction))
     assert_response :forbidden, "should need to be moderator to redact."
   end
 
@@ -192,10 +207,10 @@ class OldNodeControllerTest < ActionController::TestCase
   # test that, even as moderator, the current version of a node
   # can't be redacted.
   def test_redact_node_current_version
-    basic_authorization(users(:moderator_user).email, "test")
+    basic_authorization(create(:moderator_user).email, "test")
 
     do_redact_node(nodes(:node_with_versions_v4),
-                   redactions(:example))
+                   create(:redaction))
     assert_response :bad_request, "shouldn't be OK to redact current version as moderator."
   end
 
@@ -235,9 +250,9 @@ class OldNodeControllerTest < ActionController::TestCase
   # authorised as a moderator.
   def test_redact_node_moderator
     node = nodes(:node_with_versions_v3)
-    basic_authorization(users(:moderator_user).email, "test")
+    basic_authorization(create(:moderator_user).email, "test")
 
-    do_redact_node(node, redactions(:example))
+    do_redact_node(node, create(:redaction))
     assert_response :success, "should be OK to redact old version as moderator."
 
     # check moderator can still see the redacted data, when passing
@@ -260,13 +275,13 @@ class OldNodeControllerTest < ActionController::TestCase
   # redacted stuff any more.
   def test_redact_node_is_redacted
     node = nodes(:node_with_versions_v3)
-    basic_authorization(users(:moderator_user).email, "test")
+    basic_authorization(create(:moderator_user).email, "test")
 
-    do_redact_node(node, redactions(:example))
+    do_redact_node(node, create(:redaction))
     assert_response :success, "should be OK to redact old version as moderator."
 
     # re-auth as non-moderator
-    basic_authorization(users(:public_user).email, "test")
+    basic_authorization(create(:user).email, "test")
 
     # check can't see the redacted data
     get :version, :id => node.node_id, :version => node.version
@@ -292,8 +307,9 @@ class OldNodeControllerTest < ActionController::TestCase
   # test the unredaction of an old version of a node, while being
   # authorised as a normal user.
   def test_unredact_node_normal_user
+    user = create(:user)
     node = nodes(:redacted_node_redacted_version)
-    basic_authorization(users(:public_user).email, "test")
+    basic_authorization(user.email, "test")
 
     post :redact, :id => node.node_id, :version => node.version
     assert_response :forbidden, "should need to be moderator to unredact."
@@ -303,8 +319,9 @@ class OldNodeControllerTest < ActionController::TestCase
   # test the unredaction of an old version of a node, while being
   # authorised as a moderator.
   def test_unredact_node_moderator
+    moderator_user = create(:moderator_user)
     node = nodes(:redacted_node_redacted_version)
-    basic_authorization(users(:moderator_user).email, "test")
+    basic_authorization(moderator_user.email, "test")
 
     post :redact, :id => node.node_id, :version => node.version
     assert_response :success, "should be OK to redact old version as moderator."
@@ -319,16 +336,16 @@ class OldNodeControllerTest < ActionController::TestCase
     assert_response :success, "Unredaction shouldn't have stopped history working."
     assert_select "osm node[id='#{node.node_id}'][version='#{node.version}']", 1, "node #{node.node_id} version #{node.version} should now be present in the history for moderators without passing flag."
 
-    basic_authorization(users(:normal_user).email, "test")
+    basic_authorization(create(:user).email, "test")
 
     # check normal user can now see the redacted data
     get :version, :id => node.node_id, :version => node.version
-    assert_response :success, "After unredaction, node should not be gone for moderator."
+    assert_response :success, "After unredaction, node should be visible to normal users."
 
     # and when accessed via history
     get :history, :id => node.node_id
     assert_response :success, "Unredaction shouldn't have stopped history working."
-    assert_select "osm node[id='#{node.node_id}'][version='#{node.version}']", 1, "node #{node.node_id} version #{node.version} should now be present in the history for moderators without passing flag."
+    assert_select "osm node[id='#{node.node_id}'][version='#{node.version}']", 1, "node #{node.node_id} version #{node.version} should now be present in the history for normal users without passing flag."
   end
 
   private
@@ -377,4 +394,10 @@ class OldNodeControllerTest < ActionController::TestCase
   def precision(f)
     (f * GeoRecord::SCALE).round.to_f / GeoRecord::SCALE
   end
+
+  def propagate_tags(node, old_node)
+    node.tags.each do |k, v|
+      create(:old_node_tag, :old_node => old_node, :k => k, :v => v)
+    end
+  end
 end