<?xml version="1.0" encoding="UTF-8"?>
<commit>
  <added type="array"/>
  <modified type="array">
    <modified>
      <diff>@@ -1,41 +1,4 @@
 class CommentsController &lt; ApplicationController
-  # GET /comments
-  # GET /comments.xml
-  def index
-    @comments = Comment.find(:all)
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml =&gt; @comments }
-    end
-  end
-
-  # GET /comments/1
-  # GET /comments/1.xml
-  def show
-    @comment = Comment.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml =&gt; @comment }
-    end
-  end
-
-  # GET /comments/new
-  # GET /comments/new.xml
-  def new
-    @comment = Comment.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml =&gt; @comment }
-    end
-  end
-
-  # GET /comments/1/edit
-  def edit
-    @comment = Comment.find(params[:id])
-  end
 
   # POST /comments
   # POST /comments.xml
@@ -54,32 +17,4 @@ class CommentsController &lt; ApplicationController
     end
   end
 
-  # PUT /comments/1
-  # PUT /comments/1.xml
-  def update
-    @comment = Comment.find(params[:id])
-
-    respond_to do |format|
-      if @comment.update_attributes(params[:comment])
-        flash[:notice] = 'Comment was successfully updated.'
-        format.html { redirect_to(@comment) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action =&gt; &quot;edit&quot; }
-        format.xml  { render :xml =&gt; @comment.errors, :status =&gt; :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE /comments/1
-  # DELETE /comments/1.xml
-  def destroy
-    @comment = Comment.find(params[:id])
-    @comment.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(comments_url) }
-      format.xml  { head :ok }
-    end
-  end
 end</diff>
      <filename>app/controllers/comments_controller.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,41 +1,5 @@
 class PaymentsController &lt; ApplicationController
-  # GET /payments
-  # GET /payments.xml
-  def index
-    @payments = Payment.find(:all)
 
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml =&gt; @payments }
-    end
-  end
-
-  # GET /payments/1
-  # GET /payments/1.xml
-  def show
-    @payment = Payment.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml =&gt; @payment }
-    end
-  end
-
-  # GET /payments/new
-  # GET /payments/new.xml
-  def new
-    @payment = Payment.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml =&gt; @payment }
-    end
-  end
-
-  # GET /payments/1/edit
-  def edit
-    @payment = Payment.find(params[:id])
-  end
 
   # POST /payments
   # POST /payments.xml
@@ -54,32 +18,4 @@ class PaymentsController &lt; ApplicationController
     end
   end
 
-  # PUT /payments/1
-  # PUT /payments/1.xml
-  def update
-    @payment = Payment.find(params[:id])
-
-    respond_to do |format|
-      if @payment.update_attributes(params[:payment])
-        flash[:notice] = 'Payment was successfully updated.'
-        format.html { redirect_to(@payment) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action =&gt; &quot;edit&quot; }
-        format.xml  { render :xml =&gt; @payment.errors, :status =&gt; :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE /payments/1
-  # DELETE /payments/1.xml
-  def destroy
-    @payment = Payment.find(params[:id])
-    @payment.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(payments_url) }
-      format.xml  { head :ok }
-    end
-  end
 end</diff>
      <filename>app/controllers/payments_controller.rb</filename>
    </modified>
    <modified>
      <diff>@@ -10,32 +10,6 @@ class SpeakersController &lt; ApplicationController
     end
   end
 
-  # GET /speakers/1
-  # GET /speakers/1.xml
-  def show
-    @speaker = Speaker.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml =&gt; @speaker }
-    end
-  end
-
-  # GET /speakers/new
-  # GET /speakers/new.xml
-  def new
-    @speaker = Speaker.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml =&gt; @speaker }
-    end
-  end
-
-  # GET /speakers/1/edit
-  def edit
-    @speaker = Speaker.find(params[:id])
-  end
 
   # POST /speakers
   # POST /speakers.xml
@@ -54,22 +28,6 @@ class SpeakersController &lt; ApplicationController
     end
   end
 
-  # PUT /speakers/1
-  # PUT /speakers/1.xml
-  def update
-    @speaker = Speaker.find(params[:id])
-
-    respond_to do |format|
-      if @speaker.update_attributes(params[:speaker])
-        flash[:notice] = 'Speaker was successfully updated.'
-        format.html { redirect_to(@speaker) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action =&gt; &quot;edit&quot; }
-        format.xml  { render :xml =&gt; @speaker.errors, :status =&gt; :unprocessable_entity }
-      end
-    end
-  end
 
   # DELETE /speakers/1
   # DELETE /speakers/1.xml</diff>
      <filename>app/controllers/speakers_controller.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,6 +1,29 @@
 class UsersController &lt; ApplicationController
 
-  # render new.rhtml
+
+  # GET /users
+  # GET /users.xml
+  def index
+    @users = User.find(:all)
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml =&gt; @users }
+    end
+  end
+
+  # GET /users/1
+  # GET /users/1.xml
+  def show
+    @user = User.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml =&gt; @user }
+    end
+  end
+
+
   def new
     @user = User.new
   end
@@ -37,4 +60,41 @@ class UsersController &lt; ApplicationController
       redirect_back_or_default('/')
     end
   end
+  
+  # GET /users/1/edit
+  def edit
+    @user = User.find(params[:id])
+  end
+
+  # PUT /users/1
+  # PUT /users/1.xml
+  def update
+    @user = User.find(params[:id])
+
+    puts @user.valid?
+    puts @user.errors.full_messages
+    
+    respond_to do |format|
+      if @user.update_attributes(params[:user])
+        flash[:notice] = 'User was successfully updated.'
+        format.html { redirect_to(@user) }
+        format.xml  { head :ok }
+      else
+        format.html { render :action =&gt; &quot;edit&quot; }
+        format.xml  { render :xml =&gt; @user.errors, :status =&gt; :unprocessable_entity }
+      end
+    end
+  end
+  
+  # DELETE /rooms/1
+  # DELETE /rooms/1.xml
+  def destroy
+    @user = User.find(params[:id])
+    @user.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(users_url) }
+      format.xml  { head :ok }
+    end
+  end
 end</diff>
      <filename>app/controllers/users_controller.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,41 +1,4 @@
 class VotesController &lt; ApplicationController
-  # GET /votes
-  # GET /votes.xml
-  def index
-    @votes = Vote.find(:all)
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml =&gt; @votes }
-    end
-  end
-
-  # GET /votes/1
-  # GET /votes/1.xml
-  def show
-    @vote = Vote.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml =&gt; @vote }
-    end
-  end
-
-  # GET /votes/new
-  # GET /votes/new.xml
-  def new
-    @vote = Vote.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml =&gt; @vote }
-    end
-  end
-
-  # GET /votes/1/edit
-  def edit
-    @vote = Vote.find(params[:id])
-  end
 
   # POST /votes
   # POST /votes.xml
@@ -70,16 +33,4 @@ class VotesController &lt; ApplicationController
       end
     end
   end
-
-  # DELETE /votes/1
-  # DELETE /votes/1.xml
-  def destroy
-    @vote = Vote.find(params[:id])
-    @vote.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(votes_url) }
-      format.xml  { head :ok }
-    end
-  end
 end</diff>
      <filename>app/controllers/votes_controller.rb</filename>
    </modified>
    <modified>
      <diff>@@ -2,7 +2,7 @@ class NotDeletableEventException &lt; Exception
 end
 
 class Event &lt; ActiveRecord::Base
-  has_many :payments
+  has_many :payments, :dependent =&gt; :destroy
   
   validates_presence_of :name
   validates_presence_of :description</diff>
      <filename>app/models/event.rb</filename>
    </modified>
    <modified>
      <diff>@@ -3,16 +3,25 @@ if ARGV[0].nil?
   exit
 end
 
-File.read(ARGV[0]).each do |line|
+if not File.exists?(ARGV[0])
+  puts &quot;Fichero no encontrado: #{ARGV[0]}&quot; 
+  exit
+end
+
+result = &quot;&quot;
+
+File.open(ARGV[0]).read.each do |line|
   if line =~ /^\s*test &quot;.*&quot; do$/
-    line.gsub!( /\&quot;\sdo\s*$/, &quot;&quot; )
+    line.gsub!( /\&quot;\sdo\s*/, &quot;&quot; )
     line.gsub!( /&quot;/, &quot;&quot; )
     line.gsub!( /^\s*/, &quot;&quot; )
     line.gsub!( /\s/, &quot;_&quot; )
     line.gsub!( /^/, &quot;def &quot;)
 
-    line = &quot;  &quot; + line
+    line = &quot;  &quot; + line + &quot;\n&quot;
   end
   
-  puts line
-end
\ No newline at end of file
+  result &lt;&lt; line
+end
+
+File.new( ARGV[0], &quot;w+&quot; ).puts( result )
\ No newline at end of file</diff>
      <filename>script/convert_new_test_sintaxis_to_old_test_sintaxis.rb</filename>
    </modified>
    <modified>
      <diff>@@ -3,4 +3,8 @@
 
 room1:
   name: Room 1
-  notes: Just a Room
\ No newline at end of file
+  notes: Just a Room
+  
+room2:
+  name: Room 2
+  notes: Just a Room 2
\ No newline at end of file</diff>
      <filename>test/fixtures/rooms.yml</filename>
    </modified>
    <modified>
      <diff>@@ -13,9 +13,11 @@ user1:
   login: user1
   email: user1@email.com
   crypted_password: aaa
+  role: &lt;%= User::ROLE_USER %&gt;
   
 user2:
   name: User 2
   login: user2
   email: user2@email.com
-  crypted_password: aaa
\ No newline at end of file
+  crypted_password: aaa
+  role: &lt;%= User::ROLE_USER %&gt;</diff>
      <filename>test/fixtures/users.yml</filename>
    </modified>
    <modified>
      <diff>@@ -1,43 +1,44 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class AttendsControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
+  def setup
+    @paper = papers(:paper2)
+    @user = users(:user2)
+  end
+  
+  def test_should_get_index
     get :index
     assert_response :success
     assert_not_nil assigns(:attends)
   end
 
-  test &quot;should get new&quot; do
+  def test_should_get_new
     get :new
     assert_response :success
   end
 
-  test &quot;should create attend&quot; do
+  def test_should_create_attend
     assert_difference('Attend.count') do
-      post :create, :attend =&gt; { }
+      post(
+        :create, 
+        :attend =&gt; {
+          :paper_id =&gt; @paper.id,
+          :user_id  =&gt; @user.id
+        }
+      )
     end
 
     assert_redirected_to attend_path(assigns(:attend))
   end
 
-  test &quot;should show attend&quot; do
-    get :show, :id =&gt; attends(:one).id
-    assert_response :success
-  end
-
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; attends(:one).id
+  def test_should_show_attend
+    get :show, :id =&gt; attends(:user1_go_paper1).id
     assert_response :success
   end
 
-  test &quot;should update attend&quot; do
-    put :update, :id =&gt; attends(:one).id, :attend =&gt; { }
-    assert_redirected_to attend_path(assigns(:attend))
-  end
-
-  test &quot;should destroy attend&quot; do
+  def test_should_destroy_attend
     assert_difference('Attend.count', -1) do
-      delete :destroy, :id =&gt; attends(:one).id
+      delete :destroy, :id =&gt; attends(:user1_go_paper1).id
     end
 
     assert_redirected_to attends_path</diff>
      <filename>test/functional/attends_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,45 +1,19 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class CommentsControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
-    get :index
-    assert_response :success
-    assert_not_nil assigns(:comments)
-  end
-
-  test &quot;should get new&quot; do
-    get :new
-    assert_response :success
-  end
-
-  test &quot;should create comment&quot; do
+  
+  def test_should_create_comment
     assert_difference('Comment.count') do
-      post :create, :comment =&gt; { }
+      post(
+        :create, 
+        :comment =&gt; { 
+          :paper_id =&gt; papers(:paper2).id,
+          :user_id  =&gt; users(:user2).id,
+          :text     =&gt; 'text'
+        }
+      )
     end
 
     assert_redirected_to comment_path(assigns(:comment))
   end
-
-  test &quot;should show comment&quot; do
-    get :show, :id =&gt; comments(:one).id
-    assert_response :success
-  end
-
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; comments(:one).id
-    assert_response :success
-  end
-
-  test &quot;should update comment&quot; do
-    put :update, :id =&gt; comments(:one).id, :comment =&gt; { }
-    assert_redirected_to comment_path(assigns(:comment))
-  end
-
-  test &quot;should destroy comment&quot; do
-    assert_difference('Comment.count', -1) do
-      delete :destroy, :id =&gt; comments(:one).id
-    end
-
-    assert_redirected_to comments_path
-  end
 end</diff>
      <filename>test/functional/comments_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,43 +1,43 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class EventsControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
+  def test_should_get_index
     get :index
     assert_response :success
     assert_not_nil assigns(:events)
   end
 
-  test &quot;should get new&quot; do
+  def test_should_get_new
     get :new
     assert_response :success
   end
 
-  test &quot;should create event&quot; do
+  def test_should_create_event
     assert_difference('Event.count') do
-      post :create, :event =&gt; { }
+      post :create, :event =&gt; { :name =&gt; 'name', :description =&gt; 'description', :price_cents =&gt; 1 }
     end
 
     assert_redirected_to event_path(assigns(:event))
   end
 
-  test &quot;should show event&quot; do
-    get :show, :id =&gt; events(:one).id
+  def test_should_show_event
+    get :show, :id =&gt; events(:event1).id
     assert_response :success
   end
 
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; events(:one).id
+  def test_should_get_edit
+    get :edit, :id =&gt; events(:event1).id
     assert_response :success
   end
 
-  test &quot;should update event&quot; do
-    put :update, :id =&gt; events(:one).id, :event =&gt; { }
+  def test_should_update_event
+    put :update, :id =&gt; events(:event1).id, :event =&gt; { :name =&gt; 'other name' }
     assert_redirected_to event_path(assigns(:event))
   end
 
-  test &quot;should destroy event&quot; do
+  def test_should_destroy_event
     assert_difference('Event.count', -1) do
-      delete :destroy, :id =&gt; events(:one).id
+      delete :destroy, :id =&gt; events(:event2).id
     end
 
     assert_redirected_to events_path</diff>
      <filename>test/functional/events_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,43 +1,51 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class PapersControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
+  def test_should_get_index
     get :index
     assert_response :success
     assert_not_nil assigns(:papers)
   end
 
-  test &quot;should get new&quot; do
+  def test_should_get_new
     get :new
     assert_response :success
   end
 
-  test &quot;should create paper&quot; do
+  def test_should_create_paper
     assert_difference('Paper.count') do
-      post :create, :paper =&gt; { }
+      post(
+        :create, 
+        :paper =&gt; { 
+          :title        =&gt; papers(:paper1).title,
+          :description  =&gt; papers(:paper1).description,
+          :family       =&gt; papers(:paper1).family,
+          :status       =&gt; papers(:paper1).status
+        }
+      )
     end
 
     assert_redirected_to paper_path(assigns(:paper))
   end
 
-  test &quot;should show paper&quot; do
-    get :show, :id =&gt; papers(:one).id
+  def test_should_show_paper
+    get :show, :id =&gt; papers(:paper1).id
     assert_response :success
   end
 
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; papers(:one).id
+  def test_should_get_edit
+    get :edit, :id =&gt; papers(:paper1).id
     assert_response :success
   end
 
-  test &quot;should update paper&quot; do
-    put :update, :id =&gt; papers(:one).id, :paper =&gt; { }
+  def test_should_update_paper
+    put :update, :id =&gt; papers(:paper1).id, :paper =&gt; { :title =&gt; 'another title' }
     assert_redirected_to paper_path(assigns(:paper))
   end
 
-  test &quot;should destroy paper&quot; do
+  def test_should_destroy_paper
     assert_difference('Paper.count', -1) do
-      delete :destroy, :id =&gt; papers(:one).id
+      delete :destroy, :id =&gt; papers(:paper1).id
     end
 
     assert_redirected_to papers_path</diff>
      <filename>test/functional/papers_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,45 +1,19 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class PaymentsControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
-    get :index
-    assert_response :success
-    assert_not_nil assigns(:payments)
-  end
-
-  test &quot;should get new&quot; do
-    get :new
-    assert_response :success
-  end
 
-  test &quot;should create payment&quot; do
+  def test_should_create_payment
     assert_difference('Payment.count') do
-      post :create, :payment =&gt; { }
+      post(
+        :create, 
+        :payment =&gt; {
+          :user_id     =&gt; users(:user1).id,
+          :event_id    =&gt; events(:event2).id
+        }
+      )
     end
 
     assert_redirected_to payment_path(assigns(:payment))
   end
 
-  test &quot;should show payment&quot; do
-    get :show, :id =&gt; payments(:one).id
-    assert_response :success
-  end
-
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; payments(:one).id
-    assert_response :success
-  end
-
-  test &quot;should update payment&quot; do
-    put :update, :id =&gt; payments(:one).id, :payment =&gt; { }
-    assert_redirected_to payment_path(assigns(:payment))
-  end
-
-  test &quot;should destroy payment&quot; do
-    assert_difference('Payment.count', -1) do
-      delete :destroy, :id =&gt; payments(:one).id
-    end
-
-    assert_redirected_to payments_path
-  end
 end</diff>
      <filename>test/functional/payments_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,43 +1,25 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class ResourcesControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
-    get :index
-    assert_response :success
-    assert_not_nil assigns(:resources)
-  end
-
-  test &quot;should get new&quot; do
-    get :new
-    assert_response :success
-  end
 
-  test &quot;should create resource&quot; do
+  def test_should_create_resource
     assert_difference('Resource.count') do
-      post :create, :resource =&gt; { }
+      post(
+        :create, 
+        :resource =&gt; {
+          :user_id    =&gt; users(:user1).id, 
+          :paper_id   =&gt; papers(:paper1).id, 
+          :url        =&gt; 'http://mi.url'
+        }
+      )
     end
 
     assert_redirected_to resource_path(assigns(:resource))
   end
 
-  test &quot;should show resource&quot; do
-    get :show, :id =&gt; resources(:one).id
-    assert_response :success
-  end
-
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; resources(:one).id
-    assert_response :success
-  end
-
-  test &quot;should update resource&quot; do
-    put :update, :id =&gt; resources(:one).id, :resource =&gt; { }
-    assert_redirected_to resource_path(assigns(:resource))
-  end
-
-  test &quot;should destroy resource&quot; do
+  def test_should_destroy_resource
     assert_difference('Resource.count', -1) do
-      delete :destroy, :id =&gt; resources(:one).id
+      delete :destroy, :id =&gt; resources(:resource1).id
     end
 
     assert_redirected_to resources_path</diff>
      <filename>test/functional/resources_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,43 +1,43 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class RoomsControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
+  def test_should_get_index
     get :index
     assert_response :success
     assert_not_nil assigns(:rooms)
   end
 
-  test &quot;should get new&quot; do
+  def test_should_get_new
     get :new
     assert_response :success
   end
 
-  test &quot;should create room&quot; do
+  def test_should_create_room
     assert_difference('Room.count') do
-      post :create, :room =&gt; { }
+      post :create, :room =&gt; { :name =&gt; 'room' }
     end
 
     assert_redirected_to room_path(assigns(:room))
   end
 
-  test &quot;should show room&quot; do
-    get :show, :id =&gt; rooms(:one).id
+  def test_should_show_room
+    get :show, :id =&gt; rooms(:room1).id
     assert_response :success
   end
 
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; rooms(:one).id
+  def test_should_get_edit
+    get :edit, :id =&gt; rooms(:room1).id
     assert_response :success
   end
 
-  test &quot;should update room&quot; do
-    put :update, :id =&gt; rooms(:one).id, :room =&gt; { }
+  def test_should_update_room
+    put :update, :id =&gt; rooms(:room1).id, :room =&gt; { }
     assert_redirected_to room_path(assigns(:room))
   end
 
-  test &quot;should destroy room&quot; do
+  def test_should_destroy_room
     assert_difference('Room.count', -1) do
-      delete :destroy, :id =&gt; rooms(:one).id
+      delete :destroy, :id =&gt; rooms(:room2).id
     end
 
     assert_redirected_to rooms_path</diff>
      <filename>test/functional/rooms_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,43 +1,29 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class SpeakersControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
+  def test_should_get_index
     get :index
     assert_response :success
     assert_not_nil assigns(:speakers)
   end
 
-  test &quot;should get new&quot; do
-    get :new
-    assert_response :success
-  end
-
-  test &quot;should create speaker&quot; do
+  def test_should_create_speaker
     assert_difference('Speaker.count') do
-      post :create, :speaker =&gt; { }
+      post( 
+        :create, 
+        :speaker =&gt; {
+          :user_id     =&gt; users(:user1).id,
+          :paper_id    =&gt; papers(:paper2).id
+        }
+      )
     end
 
     assert_redirected_to speaker_path(assigns(:speaker))
   end
 
-  test &quot;should show speaker&quot; do
-    get :show, :id =&gt; speakers(:one).id
-    assert_response :success
-  end
-
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; speakers(:one).id
-    assert_response :success
-  end
-
-  test &quot;should update speaker&quot; do
-    put :update, :id =&gt; speakers(:one).id, :speaker =&gt; { }
-    assert_redirected_to speaker_path(assigns(:speaker))
-  end
-
-  test &quot;should destroy speaker&quot; do
+  def test_should_destroy_speaker
     assert_difference('Speaker.count', -1) do
-      delete :destroy, :id =&gt; speakers(:one).id
+      delete :destroy, :id =&gt; speakers(:speaker_user1_paper1).id
     end
 
     assert_redirected_to speakers_path</diff>
      <filename>test/functional/speakers_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,43 +1,53 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class UsersControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
+  def test_should_get_index
     get :index
     assert_response :success
     assert_not_nil assigns(:users)
   end
 
-  test &quot;should get new&quot; do
+  def test_should_get_new
     get :new
     assert_response :success
   end
 
-  test &quot;should create user&quot; do
+  def test_should_create_user
     assert_difference('User.count') do
-      post :create, :user =&gt; { }
+      post(
+        :create, 
+        :user =&gt; {
+          :name         =&gt; 'name',
+          :login        =&gt; 'other_login',
+          :email        =&gt; 'email@email.com',
+          :password     =&gt; 'pass000',
+          :password_confirmation =&gt; 'pass000',
+          :role         =&gt; User::ROLE_USER
+        }
+      )
     end
 
     assert_redirected_to user_path(assigns(:user))
   end
 
-  test &quot;should show user&quot; do
-    get :show, :id =&gt; users(:one).id
+  def test_should_show_user
+    get :show, :id =&gt; users(:user1).id
     assert_response :success
   end
 
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; users(:one).id
+  def test_should_get_edit
+    get :edit, :id =&gt; users(:user1).id
     assert_response :success
   end
 
-  test &quot;should update user&quot; do
-    put :update, :id =&gt; users(:one).id, :user =&gt; { }
+  def test_should_update_user
+    put :update, :id =&gt; users(:user1).id, :user =&gt; { :name =&gt; 'other name' }
     assert_redirected_to user_path(assigns(:user))
   end
 
-  test &quot;should destroy user&quot; do
+  def test_should_destroy_user
     assert_difference('User.count', -1) do
-      delete :destroy, :id =&gt; users(:one).id
+      delete :destroy, :id =&gt; users(:user1).id
     end
 
     assert_redirected_to users_path</diff>
      <filename>test/functional/users_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -1,45 +1,24 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class VotesControllerTest &lt; ActionController::TestCase
-  test &quot;should get index&quot; do
-    get :index
-    assert_response :success
-    assert_not_nil assigns(:votes)
-  end
-
-  test &quot;should get new&quot; do
-    get :new
-    assert_response :success
-  end
-
-  test &quot;should create vote&quot; do
+  def test_should_create_vote
     assert_difference('Vote.count') do
-      post :create, :vote =&gt; { }
+      post(
+        :create, 
+        :vote =&gt; {
+          :user_id    =&gt; users(:user1).id, 
+          :paper_id   =&gt; papers(:paper2).id, 
+          :points     =&gt; 2
+        }
+      )
     end
 
     assert_redirected_to vote_path(assigns(:vote))
   end
 
-  test &quot;should show vote&quot; do
-    get :show, :id =&gt; votes(:one).id
-    assert_response :success
-  end
-
-  test &quot;should get edit&quot; do
-    get :edit, :id =&gt; votes(:one).id
-    assert_response :success
-  end
-
-  test &quot;should update vote&quot; do
-    put :update, :id =&gt; votes(:one).id, :vote =&gt; { }
+  def test_should_update_vote
+    put :update, :id =&gt; votes(:vote1).id, :vote =&gt; { :points =&gt; 1 }
     assert_redirected_to vote_path(assigns(:vote))
   end
 
-  test &quot;should destroy vote&quot; do
-    assert_difference('Vote.count', -1) do
-      delete :destroy, :id =&gt; votes(:one).id
-    end
-
-    assert_redirected_to votes_path
-  end
 end</diff>
      <filename>test/functional/votes_controller_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -14,7 +14,11 @@ class ResourceTest &lt; ActiveSupport::TestCase
 
   def test_create
     assert_difference &quot;Resource.count&quot;, 1 do
-      Resource.create(:user =&gt; @user, :paper =&gt; @paper, :url =&gt; 'http://mi.url')
+      Resource.create(
+        :user =&gt; @user, 
+        :paper =&gt; @paper, 
+        :url =&gt; 'http://mi.url'
+      )
     end
   end
 </diff>
      <filename>test/unit/resource_test.rb</filename>
    </modified>
    <modified>
      <diff>@@ -15,7 +15,11 @@ class VoteTest &lt; ActiveSupport::TestCase
 
   def test_create
     assert_difference &quot;Vote.count&quot;, 1 do
-      Vote.create(:user =&gt; @user, :paper =&gt; papers(:paper2), :points =&gt; 2)
+      Vote.create(
+        :user =&gt; @user, 
+        :paper =&gt; papers(:paper2), 
+        :points =&gt; 2
+      )
     end
   end
 </diff>
      <filename>test/unit/vote_test.rb</filename>
    </modified>
  </modified>
  <removed type="array">
    <removed>
      <filename>test/functional/roles_controller_test.rb</filename>
    </removed>
  </removed>
  <parents type="array">
    <parent>
      <id>f19ccef6833e9974dc0ded81ccc4d90a26e23972</id>
    </parent>
  </parents>
  <author>
    <name>Fernando Guillen</name>
    <email>fguillen.mail@gmail.com</email>
  </author>
  <url>http://github.com/fguillen/euruko_app/commit/882459101526d9b6be4f78f00984941d059c16ea</url>
  <id>882459101526d9b6be4f78f00984941d059c16ea</id>
  <committed-date>2008-12-21T13:53:51-08:00</committed-date>
  <authored-date>2008-12-21T13:53:51-08:00</authored-date>
  <message>functional tests</message>
  <tree>5d8670a370d0cebf4012d8fc77bb2a4e109c643a</tree>
  <committer>
    <name>Fernando Guillen</name>
    <email>fguillen.mail@gmail.com</email>
  </committer>
</commit>
