X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/8441bcf17361a0803ae0de0bcac0995a04f14bdd..cedbd885b757aa18150e32493c29ddbac5ba2da7:/test/controllers/changeset_controller_test.rb

diff --git a/test/controllers/changeset_controller_test.rb b/test/controllers/changeset_controller_test.rb
index 3fb340ee8..14338111f 100644
--- a/test/controllers/changeset_controller_test.rb
+++ b/test/controllers/changeset_controller_test.rb
@@ -178,7 +178,7 @@ class ChangesetControllerTest < ActionController::TestCase
   # check that the changeset can be read and returns the correct
   # document structure.
   def test_read
-    changeset_id = changesets(:normal_user_first_change).id
+    changeset_id = create(:changeset).id
 
     get :read, :id => changeset_id
     assert_response :success, "cannot get first changeset"
@@ -195,7 +195,7 @@ class ChangesetControllerTest < ActionController::TestCase
     assert_select "osm>changeset>discussion", 1
     assert_select "osm>changeset>discussion>comment", 0
 
-    changeset_id = changesets(:normal_user_closed_change).id
+    changeset_id = create(:changeset, :closed).id
     create_list(:changeset_comment, 3, :changeset_id => changeset_id)
 
     get :read, :id => changeset_id, :include_discussion => true
@@ -223,19 +223,24 @@ class ChangesetControllerTest < ActionController::TestCase
   ##
   # test that the user who opened a change can close it
   def test_close
+    private_user = create(:user, :data_public => false)
+    private_changeset = create(:changeset, :user => private_user)
+    user = create(:user)
+    changeset = create(:changeset, :user => user)
+
     ## Try without authentication
-    put :close, :id => changesets(:public_user_first_change).id
+    put :close, :id => changeset.id
     assert_response :unauthorized
 
     ## Try using the non-public user
-    basic_authorization changesets(:normal_user_first_change).user.email, "test"
-    put :close, :id => changesets(:normal_user_first_change).id
+    basic_authorization private_user.email, "test"
+    put :close, :id => private_changeset.id
     assert_require_public_data
 
     ## The try with the public user
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
+    basic_authorization user.email, "test"
 
-    cs_id = changesets(:public_user_first_change).id
+    cs_id = changeset.id
     put :close, :id => cs_id
     assert_response :success
 
@@ -248,9 +253,12 @@ class ChangesetControllerTest < ActionController::TestCase
   ##
   # test that a different user can't close another user's changeset
   def test_close_invalid
-    basic_authorization create(:user).email, "test"
+    user = create(:user)
+    changeset = create(:changeset)
 
-    put :close, :id => changesets(:normal_user_first_change).id
+    basic_authorization user.email, "test"
+
+    put :close, :id => changeset.id
     assert_response :conflict
     assert_equal "The user doesn't own that changeset", @response.body
   end
@@ -258,13 +266,15 @@ class ChangesetControllerTest < ActionController::TestCase
   ##
   # test that you can't close using another method
   def test_close_method_invalid
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
+    user = create(:user)
+    changeset = create(:changeset, :user => user)
 
-    cs_id = changesets(:public_user_first_change).id
-    get :close, :id => cs_id
+    basic_authorization user.email, "test"
+
+    get :close, :id => changeset.id
     assert_response :method_not_allowed
 
-    post :close, :id => cs_id
+    post :close, :id => changeset.id
     assert_response :method_not_allowed
   end
 
@@ -300,24 +310,38 @@ class ChangesetControllerTest < ActionController::TestCase
   # be read back ok
   # Also try without auth and another user.
   def test_upload_simple_valid
+    private_user = create(:user, :data_public => false)
+    private_changeset = create(:changeset, :user => private_user)
+    user = create(:user)
+    changeset = create(:changeset, :user => user)
+
+    node = create(:node)
+    way = create(:way)
+    relation = create(:relation)
+    other_relation = create(:relation)
+    # create some tags, since we test that they are removed later
+    create(:node_tag, :node => node)
+    create(:way_tag, :way => way)
+    create(:relation_tag, :relation => relation)
+
     ## Try with no auth
-    changeset_id = changesets(:public_user_first_change).id
+    changeset_id = changeset.id
 
     # simple diff to change a node, way and relation by removing
     # their tags
     diff = <<EOF
 <osmChange>
  <modify>
-  <node id='1' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
-  <way id='1' changeset='#{changeset_id}' version='1'>
-   <nd ref='3'/>
+  <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
+  <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
+   <nd ref='#{node.id}'/>
   </way>
  </modify>
  <modify>
-  <relation id='1' changeset='#{changeset_id}' version='1'>
-   <member type='way' role='some' ref='3'/>
-   <member type='node' role='some' ref='5'/>
-   <member type='relation' role='some' ref='3'/>
+  <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
+   <member type='way' role='some' ref='#{way.id}'/>
+   <member type='node' role='some' ref='#{node.id}'/>
+   <member type='relation' role='some' ref='#{other_relation.id}'/>
   </relation>
  </modify>
 </osmChange>
@@ -327,27 +351,27 @@ EOF
     content diff
     post :upload, :id => changeset_id
     assert_response :unauthorized,
-                    "shouldnn't be able to upload a simple valid diff to changeset: #{@response.body}"
+                    "shouldn't be able to upload a simple valid diff to changeset: #{@response.body}"
 
     ## Now try with a private user
-    basic_authorization changesets(:normal_user_first_change).user.email, "test"
-    changeset_id = changesets(:normal_user_first_change).id
+    basic_authorization private_user.email, "test"
+    changeset_id = private_changeset.id
 
     # simple diff to change a node, way and relation by removing
     # their tags
     diff = <<EOF
 <osmChange>
  <modify>
-  <node id='1' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
-  <way id='1' changeset='#{changeset_id}' version='1'>
-   <nd ref='3'/>
+  <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
+  <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
+   <nd ref='#{node.id}'/>
   </way>
  </modify>
  <modify>
-  <relation id='1' changeset='#{changeset_id}' version='1'>
-   <member type='way' role='some' ref='3'/>
-   <member type='node' role='some' ref='5'/>
-   <member type='relation' role='some' ref='3'/>
+  <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
+   <member type='way' role='some' ref='#{way.id}'/>
+   <member type='node' role='some' ref='#{node.id}'/>
+   <member type='relation' role='some' ref='#{other_relation.id}'/>
   </relation>
  </modify>
 </osmChange>
@@ -360,24 +384,24 @@ EOF
                     "can't upload a simple valid diff to changeset: #{@response.body}"
 
     ## Now try with the public user
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
-    changeset_id = changesets(:public_user_first_change).id
+    basic_authorization user.email, "test"
+    changeset_id = changeset.id
 
     # simple diff to change a node, way and relation by removing
     # their tags
     diff = <<EOF
 <osmChange>
  <modify>
-  <node id='1' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
-  <way id='1' changeset='#{changeset_id}' version='1'>
-   <nd ref='3'/>
+  <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
+  <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
+   <nd ref='#{node.id}'/>
   </way>
  </modify>
  <modify>
-  <relation id='1' changeset='#{changeset_id}' version='1'>
-   <member type='way' role='some' ref='3'/>
-   <member type='node' role='some' ref='5'/>
-   <member type='relation' role='some' ref='3'/>
+  <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
+   <member type='way' role='some' ref='#{way.id}'/>
+   <member type='node' role='some' ref='#{node.id}'/>
+   <member type='relation' role='some' ref='#{other_relation.id}'/>
   </relation>
  </modify>
 </osmChange>
@@ -390,31 +414,33 @@ EOF
                     "can't upload a simple valid diff to changeset: #{@response.body}"
 
     # check that the changes made it into the database
-    assert_equal 0, Node.find(1).tags.size, "node 1 should now have no tags"
-    assert_equal 0, Way.find(1).tags.size, "way 1 should now have no tags"
-    assert_equal 0, Relation.find(1).tags.size, "relation 1 should now have no tags"
+    assert_equal 0, Node.find(node.id).tags.size, "node #{node.id} should now have no tags"
+    assert_equal 0, Way.find(way.id).tags.size, "way #{way.id} should now have no tags"
+    assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
   end
 
   ##
   # upload something which creates new objects using placeholders
   def test_upload_create_valid
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
-    cs_id = changesets(:public_user_first_change).id
+    user = create(:user)
+    changeset = create(:changeset, :user => user)
+
+    basic_authorization user.email, "test"
 
     # simple diff to create a node way and relation using placeholders
     diff = <<EOF
 <osmChange>
  <create>
-  <node id='-1' lon='0' lat='0' changeset='#{cs_id}'>
+  <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
    <tag k='foo' v='bar'/>
    <tag k='baz' v='bat'/>
   </node>
-  <way id='-1' changeset='#{cs_id}'>
+  <way id='-1' changeset='#{changeset.id}'>
    <nd ref='3'/>
   </way>
  </create>
  <create>
-  <relation id='-1' changeset='#{cs_id}'>
+  <relation id='-1' changeset='#{changeset.id}'>
    <member type='way' role='some' ref='3'/>
    <member type='node' role='some' ref='5'/>
    <member type='relation' role='some' ref='3'/>
@@ -425,7 +451,7 @@ EOF
 
     # upload it
     content diff
-    post :upload, :id => cs_id
+    post :upload, :id => changeset.id
     assert_response :success,
                     "can't upload a simple valid creation to changeset: #{@response.body}"
 
@@ -461,28 +487,36 @@ EOF
   # test a complex delete where we delete elements which rely on eachother
   # in the same transaction.
   def test_upload_delete
-    basic_authorization changesets(:public_user_first_change).user.display_name, "test"
+    changeset = create(:changeset)
+    super_relation = create(:relation)
+    used_relation = create(:relation)
+    used_way = create(:way)
+    used_node = create(:node)
+    create(:relation_member, :relation => super_relation, :member => used_relation)
+    create(:relation_member, :relation => super_relation, :member => used_way)
+    create(:relation_member, :relation => super_relation, :member => used_node)
+
+    basic_authorization changeset.user.display_name, "test"
 
     diff = XML::Document.new
     diff.root = XML::Node.new "osmChange"
     delete = XML::Node.new "delete"
     diff.root << delete
-    delete << current_relations(:visible_relation).to_xml_node
-    delete << current_relations(:used_relation).to_xml_node
-    delete << current_ways(:used_way).to_xml_node
-    delete << current_nodes(:node_used_by_relationship).to_xml_node
+    delete << super_relation.to_xml_node
+    delete << used_relation.to_xml_node
+    delete << used_way.to_xml_node
+    delete << used_node.to_xml_node
 
     # update the changeset to one that this user owns
-    changeset_id = changesets(:public_user_first_change).id
     %w(node way relation).each do |type|
       delete.find("//osmChange/delete/#{type}").each do |n|
-        n["changeset"] = changeset_id.to_s
+        n["changeset"] = changeset.id.to_s
       end
     end
 
     # upload it
     content diff
-    post :upload, :id => changeset_id
+    post :upload, :id => changeset.id
     assert_response :success,
                     "can't upload a deletion diff to changeset: #{@response.body}"
 
@@ -492,25 +526,25 @@ EOF
     assert_select "diffResult>relation", 2
 
     # check that everything was deleted
-    assert_equal false, Node.find(current_nodes(:node_used_by_relationship).id).visible
-    assert_equal false, Way.find(current_ways(:used_way).id).visible
-    assert_equal false, Relation.find(current_relations(:visible_relation).id).visible
-    assert_equal false, Relation.find(current_relations(:used_relation).id).visible
+    assert_equal false, Node.find(used_node.id).visible
+    assert_equal false, Way.find(used_way.id).visible
+    assert_equal false, Relation.find(super_relation.id).visible
+    assert_equal false, Relation.find(used_relation.id).visible
   end
 
   ##
   # test uploading a delete with no lat/lon, as they are optional in
   # the osmChange spec.
   def test_upload_nolatlon_delete
-    basic_authorization changesets(:public_user_first_change).user.display_name, "test"
+    node = create(:node)
+    changeset = create(:changeset)
 
-    node = current_nodes(:public_visible_node)
-    cs = changesets(:public_user_first_change)
-    diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{cs.id}'/></delete></osmChange>"
+    basic_authorization changeset.user.display_name, "test"
+    diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
 
     # upload it
     content diff
-    post :upload, :id => cs.id
+    post :upload, :id => changeset.id
     assert_response :success,
                     "can't upload a deletion diff to changeset: #{@response.body}"
 
@@ -591,48 +625,78 @@ EOF
   # test that deleting stuff in a transaction doesn't bypass the checks
   # to ensure that used elements are not deleted.
   def test_upload_delete_invalid
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
-    cs = changesets(:public_user_first_change)
+    changeset = create(:changeset)
+    relation = create(:relation)
+    other_relation = create(:relation)
+    used_way = create(:way)
+    used_node = create(:node)
+    create(:relation_member, :relation => relation, :member => used_way)
+    create(:relation_member, :relation => relation, :member => used_node)
+
+    basic_authorization changeset.user.email, "test"
 
     diff = XML::Document.new
     diff.root = XML::Node.new "osmChange"
     delete = XML::Node.new "delete"
     diff.root << delete
-    delete << current_relations(:public_visible_relation).to_xml_node
-    delete << current_ways(:used_way).to_xml_node
-    delete << current_nodes(:node_used_by_relationship).to_xml_node
+    delete << other_relation.to_xml_node
+    delete << used_way.to_xml_node
+    delete << used_node.to_xml_node
+
+    # update the changeset to one that this user owns
+    %w(node way relation).each do |type|
+      delete.find("//osmChange/delete/#{type}").each do |n|
+        n["changeset"] = changeset.id.to_s
+      end
+    end
 
     # upload it
     content diff
-    post :upload, :id => cs.id
+    post :upload, :id => changeset.id
     assert_response :precondition_failed,
                     "shouldn't be able to upload a invalid deletion diff: #{@response.body}"
-    assert_equal "Precondition failed: Way 3 is still used by relations 1.", @response.body
+    assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
 
     # check that nothing was, in fact, deleted
-    assert_equal true, Node.find(current_nodes(:node_used_by_relationship).id).visible
-    assert_equal true, Way.find(current_ways(:used_way).id).visible
-    assert_equal true, Relation.find(current_relations(:visible_relation).id).visible
+    assert_equal true, Node.find(used_node.id).visible
+    assert_equal true, Way.find(used_way.id).visible
+    assert_equal true, Relation.find(relation.id).visible
+    assert_equal true, Relation.find(other_relation.id).visible
   end
 
   ##
   # test that a conditional delete of an in use object works.
   def test_upload_delete_if_unused
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
-    cs = changesets(:public_user_first_change)
+    changeset = create(:changeset)
+    super_relation = create(:relation)
+    used_relation = create(:relation)
+    used_way = create(:way)
+    used_node = create(:node)
+    create(:relation_member, :relation => super_relation, :member => used_relation)
+    create(:relation_member, :relation => super_relation, :member => used_way)
+    create(:relation_member, :relation => super_relation, :member => used_node)
+
+    basic_authorization changeset.user.email, "test"
 
     diff = XML::Document.new
     diff.root = XML::Node.new "osmChange"
     delete = XML::Node.new "delete"
     diff.root << delete
     delete["if-unused"] = ""
-    delete << current_relations(:public_used_relation).to_xml_node
-    delete << current_ways(:used_way).to_xml_node
-    delete << current_nodes(:node_used_by_relationship).to_xml_node
+    delete << used_relation.to_xml_node
+    delete << used_way.to_xml_node
+    delete << used_node.to_xml_node
+
+    # update the changeset to one that this user owns
+    %w(node way relation).each do |type|
+      delete.find("//osmChange/delete/#{type}").each do |n|
+        n["changeset"] = changeset.id.to_s
+      end
+    end
 
     # upload it
     content diff
-    post :upload, :id => cs.id
+    post :upload, :id => changeset.id
     assert_response :success,
                     "can't do a conditional delete of in use objects: #{@response.body}"
 
@@ -646,37 +710,38 @@ EOF
     doc = XML::Parser.string(@response.body).parse
 
     # check the old IDs are all present and what we expect
-    assert_equal current_nodes(:node_used_by_relationship).id, doc.find("//diffResult/node").first["old_id"].to_i
-    assert_equal current_ways(:used_way).id, doc.find("//diffResult/way").first["old_id"].to_i
-    assert_equal current_relations(:public_used_relation).id, doc.find("//diffResult/relation").first["old_id"].to_i
+    assert_equal used_node.id, doc.find("//diffResult/node").first["old_id"].to_i
+    assert_equal used_way.id, doc.find("//diffResult/way").first["old_id"].to_i
+    assert_equal used_relation.id, doc.find("//diffResult/relation").first["old_id"].to_i
 
     # check the new IDs are all present and unchanged
-    assert_equal current_nodes(:node_used_by_relationship).id, doc.find("//diffResult/node").first["new_id"].to_i
-    assert_equal current_ways(:used_way).id, doc.find("//diffResult/way").first["new_id"].to_i
-    assert_equal current_relations(:public_used_relation).id, doc.find("//diffResult/relation").first["new_id"].to_i
+    assert_equal used_node.id, doc.find("//diffResult/node").first["new_id"].to_i
+    assert_equal used_way.id, doc.find("//diffResult/way").first["new_id"].to_i
+    assert_equal used_relation.id, doc.find("//diffResult/relation").first["new_id"].to_i
 
     # check the new versions are all present and unchanged
-    assert_equal current_nodes(:node_used_by_relationship).version, doc.find("//diffResult/node").first["new_version"].to_i
-    assert_equal current_ways(:used_way).version, doc.find("//diffResult/way").first["new_version"].to_i
-    assert_equal current_relations(:public_used_relation).version, doc.find("//diffResult/relation").first["new_version"].to_i
+    assert_equal used_node.version, doc.find("//diffResult/node").first["new_version"].to_i
+    assert_equal used_way.version, doc.find("//diffResult/way").first["new_version"].to_i
+    assert_equal used_relation.version, doc.find("//diffResult/relation").first["new_version"].to_i
 
     # check that nothing was, in fact, deleted
-    assert_equal true, Node.find(current_nodes(:node_used_by_relationship).id).visible
-    assert_equal true, Way.find(current_ways(:used_way).id).visible
-    assert_equal true, Relation.find(current_relations(:public_used_relation).id).visible
+    assert_equal true, Node.find(used_node.id).visible
+    assert_equal true, Way.find(used_way.id).visible
+    assert_equal true, Relation.find(used_relation.id).visible
   end
 
   ##
   # upload an element with a really long tag value
   def test_upload_invalid_too_long_tag
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
-    cs_id = changesets(:public_user_first_change).id
+    changeset = create(:changeset)
+
+    basic_authorization changeset.user.email, "test"
 
     # simple diff to create a node way and relation using placeholders
     diff = <<EOF
 <osmChange>
  <create>
-  <node id='-1' lon='0' lat='0' changeset='#{cs_id}'>
+  <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
    <tag k='foo' v='#{'x' * 256}'/>
   </node>
  </create>
@@ -685,7 +750,7 @@ EOF
 
     # upload it
     content diff
-    post :upload, :id => cs_id
+    post :upload, :id => changeset.id
     assert_response :bad_request,
                     "shoudln't be able to upload too long a tag to changeset: #{@response.body}"
   end
@@ -694,27 +759,33 @@ EOF
   # upload something which creates new objects and inserts them into
   # existing containers using placeholders.
   def test_upload_complex
-    basic_authorization changesets(:public_user_first_change).user.email, "test"
-    cs_id = changesets(:public_user_first_change).id
+    way = create(:way)
+    node = create(:node)
+    relation = create(:relation)
+    create(:way_node, :way => way, :node => node)
+
+    changeset = create(:changeset)
+
+    basic_authorization changeset.user.email, "test"
 
     # simple diff to create a node way and relation using placeholders
     diff = <<EOF
 <osmChange>
  <create>
-  <node id='-1' lon='0' lat='0' changeset='#{cs_id}'>
+  <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
    <tag k='foo' v='bar'/>
    <tag k='baz' v='bat'/>
   </node>
  </create>
  <modify>
-  <way id='1' changeset='#{cs_id}' version='1'>
+  <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
    <nd ref='-1'/>
-   <nd ref='3'/>
+   <nd ref='#{node.id}'/>
   </way>
-  <relation id='1' changeset='#{cs_id}' version='1'>
-   <member type='way' role='some' ref='3'/>
+  <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
+   <member type='way' role='some' ref='#{way.id}'/>
    <member type='node' role='some' ref='-1'/>
-   <member type='relation' role='some' ref='3'/>
+   <member type='relation' role='some' ref='#{relation.id}'/>
   </relation>
  </modify>
 </osmChange>
@@ -722,7 +793,7 @@ EOF
 
     # upload it
     content diff
-    post :upload, :id => cs_id
+    post :upload, :id => changeset.id
     assert_response :success,
                     "can't upload a complex diff to changeset: #{@response.body}"
 
@@ -738,8 +809,8 @@ EOF
 
     # check that the changes made it into the database
     assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
-    assert_equal [new_node_id, 3], Way.find(1).nds, "way nodes should match"
-    Relation.find(1).members.each do |type, id, _role|
+    assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
+    Relation.find(relation.id).members.each do |type, id, _role|
       if type == "node"
         assert_equal new_node_id, id, "relation should contain new node"
       end
@@ -1636,9 +1707,13 @@ EOF
   ##
   # check updating tags on a changeset
   def test_changeset_update
+    private_user = create(:user, :data_public => false)
+    private_changeset = create(:changeset, :user => private_user)
+    user = create(:user)
+    changeset = create(:changeset, :user => user)
+
     ## First try with a non-public user
-    changeset = changesets(:normal_user_first_change)
-    new_changeset = changeset.to_xml
+    new_changeset = private_changeset.to_xml
     new_tag = XML::Node.new "tag"
     new_tag["k"] = "tagtesting"
     new_tag["v"] = "valuetesting"
@@ -1646,21 +1721,20 @@ EOF
     content new_changeset
 
     # try without any authorization
-    put :update, :id => changeset.id
+    put :update, :id => private_changeset.id
     assert_response :unauthorized
 
     # try with the wrong authorization
     basic_authorization create(:user).email, "test"
-    put :update, :id => changeset.id
+    put :update, :id => private_changeset.id
     assert_response :conflict
 
     # now this should get an unauthorized
-    basic_authorization changeset.user.email, "test"
-    put :update, :id => changeset.id
+    basic_authorization private_user.email, "test"
+    put :update, :id => private_changeset.id
     assert_require_public_data "user with their data non-public, shouldn't be able to edit their changeset"
 
     ## Now try with the public user
-    changeset = changesets(:public_user_first_change)
     create(:changeset_tag, :changeset => changeset)
     new_changeset = changeset.to_xml
     new_tag = XML::Node.new "tag"
@@ -1680,7 +1754,7 @@ EOF
     assert_response :conflict
 
     # now this should work...
-    basic_authorization changeset.user.email, "test"
+    basic_authorization user.email, "test"
     put :update, :id => changeset.id
     assert_response :success
 
@@ -1695,7 +1769,7 @@ EOF
   def test_changeset_update_invalid
     basic_authorization create(:user).email, "test"
 
-    changeset = changesets(:normal_user_first_change)
+    changeset = create(:changeset)
     new_changeset = changeset.to_xml
     new_tag = XML::Node.new "tag"
     new_tag["k"] = "testing"
@@ -1984,16 +2058,19 @@ EOF
   # check that the changeset download for a changeset with a redacted
   # element in it doesn't contain that element.
   def test_diff_download_redacted
-    changeset_id = changesets(:public_user_first_change).id
+    changeset = create(:changeset)
+    node = create(:node, :with_history, :version => 2, :changeset => changeset)
+    node_v1 = node.old_nodes.find_by(:version => 1)
+    node_v1.redact!(create(:redaction))
 
-    get :download, :id => changeset_id
+    get :download, :id => changeset.id
     assert_response :success
 
     assert_select "osmChange", 1
-    # this changeset contains node 17 in versions 1 & 2, but 1 should
+    # this changeset contains the node in versions 1 & 2, but 1 should
     # be hidden.
-    assert_select "osmChange node[id='17']", 1
-    assert_select "osmChange node[id='17'][version='1']", 0
+    assert_select "osmChange node[id='#{node.id}']", 1
+    assert_select "osmChange node[id='#{node.id}'][version='1']", 0
   end
 
   ##
@@ -2061,7 +2138,7 @@ EOF
   # create comment fail
   def test_create_comment_fail
     # unauthorized
-    post :comment, :id => changesets(:normal_user_closed_change).id, :text => "This is a comment"
+    post :comment, :id => create(:changeset, :closed).id, :text => "This is a comment"
     assert_response :unauthorized
 
     basic_authorization(create(:user).email, "test")
@@ -2074,19 +2151,19 @@ EOF
 
     # not closed changeset
     assert_no_difference "ChangesetComment.count" do
-      post :comment, :id => changesets(:normal_user_first_change).id, :text => "This is a comment"
+      post :comment, :id => create(:changeset).id, :text => "This is a comment"
     end
     assert_response :conflict
 
     # no text
     assert_no_difference "ChangesetComment.count" do
-      post :comment, :id => changesets(:normal_user_closed_change).id
+      post :comment, :id => create(:changeset, :closed).id
     end
     assert_response :bad_request
 
     # empty text
     assert_no_difference "ChangesetComment.count" do
-      post :comment, :id => changesets(:normal_user_closed_change).id, :text => ""
+      post :comment, :id => create(:changeset, :closed).id, :text => ""
     end
     assert_response :bad_request
   end
@@ -2095,7 +2172,7 @@ EOF
   # test subscribe success
   def test_subscribe_success
     basic_authorization(create(:user).email, "test")
-    changeset = changesets(:normal_user_closed_change)
+    changeset = create(:changeset, :closed)
 
     assert_difference "changeset.subscribers.count", 1 do
       post :subscribe, :id => changeset.id
@@ -2109,7 +2186,7 @@ EOF
     user = create(:user)
 
     # unauthorized
-    changeset = changesets(:normal_user_closed_change)
+    changeset = create(:changeset, :closed)
     assert_no_difference "changeset.subscribers.count" do
       post :subscribe, :id => changeset.id
     end
@@ -2124,14 +2201,14 @@ EOF
     assert_response :not_found
 
     # not closed changeset
-    changeset = changesets(:normal_user_first_change)
+    changeset = create(:changeset)
     assert_no_difference "changeset.subscribers.count" do
       post :subscribe, :id => changeset.id
     end
     assert_response :conflict
 
     # trying to subscribe when already subscribed
-    changeset = changesets(:normal_user_subscribed_change)
+    changeset = create(:changeset, :closed)
     changeset.subscribers.push(user)
     assert_no_difference "changeset.subscribers.count" do
       post :subscribe, :id => changeset.id
@@ -2144,7 +2221,7 @@ EOF
   def test_unsubscribe_success
     user = create(:user)
     basic_authorization(user.email, "test")
-    changeset = changesets(:normal_user_subscribed_change)
+    changeset = create(:changeset, :closed)
     changeset.subscribers.push(user)
 
     assert_difference "changeset.subscribers.count", -1 do
@@ -2157,7 +2234,7 @@ EOF
   # test unsubscribe fail
   def test_unsubscribe_fail
     # unauthorized
-    changeset = changesets(:normal_user_closed_change)
+    changeset = create(:changeset, :closed)
     assert_no_difference "changeset.subscribers.count" do
       post :unsubscribe, :id => changeset.id
     end
@@ -2172,14 +2249,14 @@ EOF
     assert_response :not_found
 
     # not closed changeset
-    changeset = changesets(:normal_user_first_change)
+    changeset = create(:changeset)
     assert_no_difference "changeset.subscribers.count" do
       post :unsubscribe, :id => changeset.id
     end
     assert_response :conflict
 
     # trying to unsubscribe when not subscribed
-    changeset = changesets(:normal_user_closed_change)
+    changeset = create(:changeset, :closed)
     assert_no_difference "changeset.subscribers.count" do
       post :unsubscribe, :id => changeset.id
     end
@@ -2267,7 +2344,8 @@ EOF
   ##
   # test comments feed
   def test_comments_feed
-    create_list(:changeset_comment, 3, :changeset_id => changesets(:normal_user_closed_change).id)
+    changeset = create(:changeset, :closed)
+    create_list(:changeset_comment, 3, :changeset => changeset)
 
     get :comments_feed, :format => "rss"
     assert_response :success
@@ -2287,7 +2365,7 @@ EOF
       end
     end
 
-    get :comments_feed, :id => changesets(:normal_user_closed_change), :format => "rss"
+    get :comments_feed, :id => changeset.id, :format => "rss"
     assert_response :success
     assert_equal "application/rss+xml", @response.content_type
     assert_select "rss", :count => 1 do