RubyGems - typus - Versions diffs - 3.1.0.rc7 → 3.1.0.rc8 - Mend

typus 3.1.0.rc7 → 3.1.0.rc8

Files changed (853) hide show

data/test/app/controllers/admin/resources/associations_test.rb DELETED

@@ -1,59 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Typus::Controller::Associations
-=end
-class Admin::CategoriesControllerTest < ActionController::TestCase
-  setup do
-    @request.session[:typus_user_id] = Factory(:typus_user).id
-    @request.env['HTTP_REFERER'] = '/admin/categories'
-  end
-  ##
-  # We are in:
-  #
-  #   /admin/posts/edit/1
-  #
-  # And we see a list of comments under it:
-  #
-  #   /admin/categories/unrelate/1?resource=Post&resource_id=1
-  #   /admin/categories/unrelate/2?resource=Post&resource_id=1
-  #
-  test "unrelate (has_and_belongs_to_many)" do
-    category = Factory(:category)
-    category.posts << Factory(:post)
-    @request.env['HTTP_REFERER'] = "/admin/dashboard"
-    assert_difference('category.posts.count', -1) do
-      post :unrelate, :id => category.id, :resource => 'Post', :resource_id => category.posts.first
-    end
-    assert_response :redirect
-    assert_redirected_to @request.env['HTTP_REFERER']
-    assert_equal "Post successfully updated.", flash[:notice]
-  end
-  ##
-  # Basically we verify Admin::ResourcesController#create_with_back_to works
-  # as expected for STI models.
-  #
-  # We are editing a Case (which is an STI model). And we click on "Add New"
-  # to add a new category. Once created, we will be redirected and the new
-  # category will be assigned to the current case. Easy right?
-  #
-  test "relate using add new on sti models" do
-    category = { :name => "Category Name" }
-    kase = Factory(:case)
-    assert_difference('kase.categories.count') do
-      post :create, { :category => category, :resource => "Case", :resource_id => kase.id, :_saveandassign => true }
-    end
-  end
-end

data/test/app/controllers/admin/resources/birds_controller_test.rb.old DELETED

@@ -1,33 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Polymorphic associations.
-=end
-class Admin::BirdsControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-    @bird = Factory(:bird)
-    @image_holder = Factory(:image_holder)
-    @request.env['HTTP_REFERER'] = "/admin/birds/edit/#{@bird.id}"
-  end
-  test "relate polymorphic associations" do
-    assert_difference('@bird.image_holders.count') do
-      post :relate, :id => @bird.id,
-                    :related => { :model => 'ImageHolder',
-                                  :id => @image_holder.id,
-                                  :association_name => 'image_holders' }
-    end
-    assert_response :redirect
-    assert_redirected_to @request.env['HTTP_REFERER']
-    assert_equal "Bird successfully updated.", flash[:notice]
-  end
-end

data/test/app/controllers/admin/resources/bulk_test.rb DELETED

@@ -1,36 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Typus::Controller::Trash
-=end
-class Admin::EntryBulksControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-  end
-  test "get index will show the available bulk_actions" do
-    get :index
-    assert_equal [["Move to Trash", "bulk_destroy"]], assigns(:bulk_actions)
-  end
-  test "get bulk_destroy removes all items" do
-    @request.env['HTTP_REFERER'] = "/admin/entry_bulks"
-    10.times { Factory(:entry_bulk) }
-    items_to_destroy = EntryBulk.limit(5).map(&:id)
-    items_to_keep = EntryBulk.limit(5).offset(5).map(&:id)
-    get :bulk, :batch_action => "bulk_destroy", :selected_item_ids => items_to_destroy
-    assert_response :redirect
-    assert_redirected_to @request.env['HTTP_REFERER']
-    assert_equal items_to_keep, EntryBulk.all.map(&:id)
-  end
-end

data/test/app/controllers/admin/resources/cases_controller_test.rb.old DELETED

@@ -1,20 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Single Table Inheritance Stuff
-    - Relate objects.
-    - Unrelate objects.
-    - Create (and relate objects).
-=end
-class Admin::CasesControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-  end
-end

data/test/app/controllers/admin/resources/comments_controller_test.rb.old DELETED

@@ -1,74 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-  - Unrelate "Comment" from "Post" (Post#comments)
-  - Search by "Posts.title" (Post#comments)
-=end
-class Admin::CommentsControllerTest < ActionController::TestCase
-  setup do
-    @request.session[:typus_user_id] = Factory(:typus_user).id
-    @request.env['HTTP_REFERER'] = '/admin/categories'
-  end
-  context "Unrelate" do
-    ##
-    # We are in:
-    #
-    #   /admin/posts/edit/1
-    #
-    # And we see a list of comments under it:
-    #
-    #   /admin/comments/unrelate/1?resource=Post&resource_id=1
-    #   /admin/comments/unrelate/2?resource=Post&resource_id=1
-    #
-    # Notice that unrelating an item doesn't remove it from database unless
-    # defined on the model.
-    #
-    should "unrelate comment from post" do
-      comment = Factory(:comment)
-      @post = comment.post
-      assert_difference('@post.comments.count', -1) do
-        post :unrelate, :id => comment.id, :resource => 'Post', :resource_id => @post.id
-      end
-      assert comment.reload.post.nil?
-      assert_response :redirect
-      assert_redirected_to @request.env['HTTP_REFERER']
-      assert_equal "Post successfully updated.", flash[:notice]
-    end
-  end
-  context "Search" do
-    ##
-    # We are in:
-    #
-    #   /admin/posts
-    #
-    # And we can search by "posts.title" because "Comment" is belongs_to :post
-    #
-    should "search in Posts.title from Comments list" do
-      post_1 = Factory(:post, :title => "A title with_keyword")
-      comment_1 = Factory(:comment, :post => post_1)
-      post_2 = Factory(:post, :title => "A title without_keyword")
-      comment_2 = Factory(:comment, :post => post_2)
-      post :index, {:search => "with_keyword" }
-      assert_equal [comment_1], assigns(:items)
-      assert_not_equal [comment_2], assigns(:items)
-    end
-  end
-end

data/test/app/controllers/admin/resources/image_holders_controller_test.rb.old DELETED

@@ -1,55 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Polymorphic associations.
-=end
-class Admin::ImageHoldersControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-  end
-  test "create polymorphic association" do
-    bird = Factory(:bird)
-    assert_difference('bird.image_holders.count') do
-      post :create, { :image_holder => { :name => "ImageHolder" },
-                      :resource => "Bird", :resource_id => bird.id }
-    end
-    assert_response :redirect
-    assert_redirected_to "http://test.host/admin/birds/edit/#{bird.id}"
-    assert_equal "Bird successfully updated.", flash[:notice]
-  end
-  ##
-  # We are in:
-  #
-  #   /admin/birds/edit/1
-  #
-  # And we see a list of comments under it:
-  #
-  #   /admin/image_holders/unrelate/1?resource=Bird&resource_id=1
-  #   /admin/image_holders/unrelate/2?resource=Bird&resource_id=1
-  #   ...
-  #
-  # TODO: Eventually this code should be run in the Original model, so ideally
-  #       a Bird unrelates ImageHolder and not ImageHolder unrelates Bird.
-  #
-  test "unrelate" do
-    image_holder = Factory(:image_holder)
-    bird = Factory(:bird)
-    bird.image_holders << image_holder
-    @request.env['HTTP_REFERER'] = "/admin/birds/edit/#{bird.id}"
-    assert_difference('bird.image_holders.count', -1) do
-      post :unrelate, :id => image_holder.id, :resource => "Bird", :resource_id => bird.id
-    end
-  end
-end

data/test/app/controllers/admin/resources/invoices_controller_test.rb.old DELETED

@@ -1,71 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Invoice belongs_to Order
-=end
-class Admin::InvoicesControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-  end
-  ##
-  # Here we are using the create_with_back_to method.
-  #
-  #   /admin/invoices/new?back_to=&order_id=4&resource=Order&resource_id=4
-  #
-  context "Create an invoice from an Order" do
-    setup do
-      @order = Factory(:order)
-      @invoice = { :number => "Invoice#0000001" }
-    end
-    should "initialize the object with the params passed on the url" do
-      get :new, :resource => "Order", :resource => "Order", :order_id => @order.id
-      assert assigns(:item).order.eql?(@order)
-    end
-    # TODO: Take a look at this to refactor the create method.
-    should "create new invoice assign it to order and redirect to order" do
-      @invoice = { :number => "Invoice#0000001", :order_id => @order.id }
-      assert_difference('Invoice.count') do
-        post :create, :invoice => @invoice, :resource => "Order", :order_id => @order.id, :_saveandassign => true
-      end
-      assert_response :redirect
-      assert_redirected_to "/admin/orders/edit/#{@order.id}"
-    end
-    should_eventually "raise an error if we try to add an invoice to an order which already has an invoice" do
-      @invoice = Factory(:invoice)
-      get :new, { :resource => "Order", :resource_id => @invoice.order.id, :order_id => @invoice.order.id }
-      assert_response :unprocessable_entity
-    end
-    should_eventually "raise an error if we try to create an invoice to an order which already has an invoice" do
-      @invoice = Factory(:invoice)
-      post :create, :invoice => { :number => "Invoice#0000001" },
-                    :resource => "Order", :resource_id => @invoice.order.id, :order_id => @invoice.order.id
-      assert_response :unprocessable_entity
-    end
-  end
-  test "unrelate Invoice from Order" do
-    invoice = Factory(:invoice)
-    order = invoice.order
-    @request.env['HTTP_REFERER'] = "/admin/orders/edit/#{order.id}"
-    post :unrelate, :id => invoice.id, :resource => 'Order', :resource_id => order.id
-    assert order.reload.invoice.nil?
-    assert_equal "Order successfully updated.", flash[:notice]
-  end
-end

data/test/app/controllers/admin/resources/orders_controller_test.rb.old DELETED

@@ -1,17 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Order has_one Invoice
-=end
-class Admin::OrdersControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-  end
-end

data/test/app/controllers/admin/resources/pages_controller_test.rb.old DELETED

@@ -1,28 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Scopes
-  Hey! I do not recommend setting a default_scope because you'll probably get
-  unexpected results. This is here for testing purposes, but please, avoid
-  using this kind of stuff.
-=end
-class Admin::PagesControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-    Factory(:page)
-    Factory(:page, :status => false)
-  end
-  test "get :index returns scoped results" do
-    get :index
-    assert_equal Page.all, assigns(:items)
-  end
-end

data/test/app/controllers/admin/resources/posts_controller_test.rb.old DELETED

@@ -1,649 +0,0 @@
-require "test_helper"
-=begin
-  What's being tested here?
-    - Filters
-    - Forms
-    - Overrides
-    - Permissions
-    - Roles
-    - Views
-=end
-class Admin::PostsControllerTest < ActionController::TestCase
-  setup do
-    admin_sign_in
-    @post = Factory(:post)
-  end
-  context "Filters" do
-    should "render index with accepted params" do
-      @post.update_attributes(:published => true)
-      get :index, :published => 'true'
-      assert_response :success
-      assert_template 'index'
-      assert assigns(:items).size.eql?(1)
-      get :index, :published => 'false'
-      assert assigns(:items).size.eql?(0)
-    end
-    should "render index with accepted params - search" do
-      @post.update_attributes(:title => "neinonon")
-      get :index, :search => 'neinonon'
-      assert_response :success
-      assert_template 'index'
-      assert assigns(:items).size.eql?(1)
-      get :index, :search => 'unexisting'
-      assert assigns(:items).size.eql?(0)
-    end
-    should "render index with non-accepted params" do
-      get :index, :non_accepted_param => 'non_accepted_param'
-      assert_response :success
-      assert_template 'index'
-    end
-  end
-  context "Filters" do
-    should "be included in index" do
-      get :index
-      assert assigns(:predefined_filters).nil?
-    end
-  end
-  context "Actions" do
-    should "be edit and trash on index" do
-      get :index
-      expected = [["Edit", {"action"=>"edit"}, {}],
-                  ["Trash", {"action"=>"destroy"}, {"method"=>"delete", "confirm"=>"Trash?"}]]
-      assert_equal expected, assigns(:resource_actions)
-    end
-    context "with overriden default action on item" do
-      setup do
-        Typus::Resources.expects(:default_action_on_item).at_least_once.returns('show')
-      end
-      should "be show and trash on index" do
-        get :index
-        expected = [["Show", {"action"=>"show"}, {}],
-                    ["Trash", {"action"=>"destroy"}, {"method"=>"delete", "confirm"=>"Trash?"}]]
-        assert_equal expected, assigns(:resource_actions)
-      end
-    end
-  end
-  context "Forms" do
-    setup do
-      get :new
-    end
-    should "verify forms" do
-      assert_select "form"
-    end
-    # We have 3 inputs: 1 hidden which is the UTF8 stuff, one which is the
-    # Post#title and finally the submit button.
-    should "have 5 inputs" do
-      assert_select "form input", 5
-      # Post#title: Input
-      assert_select 'label[for="post_title"]'
-      assert_select 'input#post_title[type="text"]'
-    end
-    should "have 1 textarea" do
-      assert_select "form textarea", 1
-      # Post#body: Text Area
-      assert_select 'label[for="post_body"]'
-      assert_select 'textarea#post_body'
-    end
-    should "have 6 selectors" do
-      assert_select "form select", 6
-      # Post#created_at: Datetime
-      assert_select 'label[for="post_created_at"]'
-      assert_select 'select#post_created_at_1i'
-      assert_select 'select#post_created_at_2i'
-      assert_select 'select#post_created_at_3i'
-      assert_select 'select#post_created_at_4i'
-      assert_select 'select#post_created_at_5i'
-      # Post#status: Selector
-      assert_select 'label[for="post_status"]'
-      assert_select 'select#post_status'
-    end
-    should "have 1 template" do
-      assert_match "templates#datepicker_template_published_at", @response.body
-    end
-  end
-  context "Formats" do
-    should "render index and return xml" do
-      get :index, :format => "xml"
-      assert_response :success
-      assert_match %Q[<?xml version="1.0" encoding="UTF-8"?>], @response.body
-      assert_match %Q[<posts type="array">], @response.body
-      assert_match "<status>#{@post.status}</status>", @response.body
-      assert_match "<title>#{@post.title}</title>", @response.body
-    end
-    should "render index and return csv" do
-      expected = <<-RAW
-title;status
-#{@post.title};#{@post.status}
-       RAW
-      get :index, :format => "csv"
-      assert_response :success
-      assert_equal expected, @response.body
-    end
-    should "not instantiate resource_actions" do
-      get :index, :format => "xml"
-      assert assigns(:resource_actions).nil?
-    end
-    should "not instantiate predefined_filters" do
-      get :index, :format => "xml"
-      assert assigns(:predefined_filters).nil?
-    end
-  end
-  context "Permissions" do
-    context "Root" do
-      setup do
-        @editor = Factory(:typus_user, :email => "editor@example.com", :role => "editor")
-        @post = Factory(:post, :typus_user => @editor)
-      end
-      should "should list all posts no matter who is the owner" do
-        Post.delete_all
-        admin = TypusUser.where(:role => 'admin').first
-        2.times { Factory(:post, :typus_user => @editor) }
-        2.times { Factory(:post, :typus_user => @typus_user) }
-        Typus::Resources.expects(:only_user_items).returns(true)
-        get :index
-        assert Post.count.eql?(4)
-        assert assigns(:items).size.eql?(4)
-        assert_equal [@editor.id, @editor.id, @typus_user.id, @typus_user.id], assigns(:items).map(&:typus_user_id)
-      end
-      should "be able to edit any record" do
-        Post.all.each do |post|
-          get :edit, :id => post.id
-          assert_response :success
-          assert_template 'edit'
-        end
-      end
-      should "verify_admin_updating_an_item_does_not_change_typus_user_id_if_not_defined" do
-        _post = @post
-        post :update, :id => @post.id, :post => { :title => 'Updated by admin' }
-        assert_equal _post.typus_user_id, @post.reload.typus_user_id
-      end
-      should "verify_admin_updating_an_item_does_change_typus_user_id_to_whatever_admin_wants" do
-        post :update, :id => @post.id, :post => { :title => 'Updated', :typus_user_id => 108 }
-        assert @post.reload.typus_user_id.eql?(108)
-      end
-    end
-    context "No root" do
-      setup do
-        editor_sign_in
-        @request.env['HTTP_REFERER'] = '/admin/posts'
-      end
-      should "not be root" do
-        assert @typus_user.is_not_root?
-      end
-      should "verify_editor_can_show_any_record" do
-        Post.all.each do |post|
-          get :show, :id => post.id
-          assert_response :success
-          assert_template 'show'
-        end
-      end
-      should "verify_editor_tried_to_edit_a_post_owned_by_himself" do
-        get :edit, :id => Factory(:post, :typus_user => @typus_user).id
-        assert_response :success
-      end
-      should "verify_editor_tries_to_edit_a_post_owned_by_the_admin" do
-        get :edit, :id => Factory(:post).id
-        assert_response :unprocessable_entity
-      end
-      should "verify_editor_tries_to_show_a_post_owned_by_the_admin" do
-        get :show, :id => Factory(:post).id
-        assert_response :success
-      end
-      should "only list editor posts" do
-        Post.delete_all
-        admin = TypusUser.where(:role => 'admin').first
-        2.times { Factory(:post, :typus_user => admin) }
-        2.times { Factory(:post, :typus_user => @typus_user) }
-        Typus::Resources.expects(:only_user_items).returns(true)
-        get :index
-        assert Post.count.eql?(4)
-        assert assigns(:items).size.eql?(2)
-        assert_equal [@typus_user.id, @typus_user.id], assigns(:items).map(&:typus_user_id)
-      end
-      should "verify_editor_tries_to_show_a_post_owned_by_the_admin when only user items" do
-        Typus::Resources.expects(:only_user_items).returns(true)
-        post = Factory(:post)
-        get :show, :id => post.id
-        assert_response :unprocessable_entity
-      end
-      should "verify_typus_user_id_of_item_when_creating_record" do
-        assert_difference('Post.count') do
-          post :create, :post => { :title => "Chunky Bacon", :body => "Lorem ipsum ..." }
-        end
-        assert_equal @request.session[:typus_user_id], assigns(:item).typus_user_id
-      end
-      should "verify_editor_updating_an_item_does_not_change_typus_user_id" do
-        [ 108, nil ].each do |typus_user_id|
-          post_ = Factory(:post, :typus_user => @typus_user)
-          post :update, :id => post_.id, :post => { :title => 'Updated', :typus_user_id => @typus_user.id }
-          post_updated = Post.find(post_.id)
-          assert_equal @request.session[:typus_user_id], post_updated.typus_user_id
-        end
-      end
-    end
-  end
-  context "Roles" do
-    setup do
-      @request.env['HTTP_REFERER'] = '/admin/posts'
-    end
-    context "Admin" do
-      should "be able to add posts" do
-        assert @typus_user.can?("create", "Post")
-      end
-      should "be able to destroy posts" do
-        get :destroy, :id => Factory(:post).id, :method => :delete
-        assert_response :redirect
-        assert_equal "Post successfully removed.", flash[:notice]
-        assert_redirected_to :action => :index
-      end
-    end
-    context "Designer" do
-      setup do
-        Typus.user_class.delete_all
-        @designer = Factory(:typus_user, :role => "designer")
-        @request.session[:typus_user_id] = @designer.id
-        @post = Factory(:post)
-      end
-      should "not be able to add posts" do
-        get :new
-        assert_response :unprocessable_entity
-      end
-      should "not be able to destroy posts" do
-        assert_no_difference('Post.count') do
-          get :destroy, :id => @post.id, :method => :delete
-        end
-        assert_response :unprocessable_entity
-      end
-    end
-  end
-=begin
-  # TODO: This stuff has changed a lot! We need to rewrite the tests.
-  context "Relationships (relate)" do
-    setup do
-      @post = Factory(:post)
-    end
-    should "relate comment to post (has_many)" do
-      comment = Factory(:comment, :post => nil)
-      @request.env['HTTP_REFERER'] = "/admin/posts/edit/#{@post.id}#comments"
-      assert_difference('@post.comments.count') do
-        post :relate, :id => @post.id, :related => { :model => 'Comment', :id => comment.id, :association_name => 'comments' }
-      end
-      assert_response :redirect
-      assert_redirected_to @request.env['HTTP_REFERER']
-      assert_equal "Post successfully updated.", flash[:notice]
-    end
-    should "return a message instead a 404 error if related_id is empty" do
-      comment = Factory(:comment, :post => nil)
-      @request.env['HTTP_REFERER'] = "/admin/posts/edit/#{@post.id}#comments"
-      assert_no_difference('@post.comments.count') do
-        post :relate, :id => @post.id, :related => { :model => 'Comment', :id => "", :association_name => 'comments' }
-      end
-      assert_response :redirect
-      assert_redirected_to @request.env['HTTP_REFERER']
-      assert_equal "Please, select an option.", flash[:notice]
-    end
-    should "return a message instead a 404 error if related_id is nil" do
-      comment = Factory(:comment, :post => nil)
-      @request.env['HTTP_REFERER'] = "/admin/posts/edit/#{@post.id}#comments"
-      assert_no_difference('@post.comments.count') do
-        post :relate, :id => @post.id, :related => { :model => 'Comment', :id => nil, :association_name => 'comments' }
-      end
-      assert_response :redirect
-      assert_redirected_to @request.env['HTTP_REFERER']
-      assert_equal "Please, select an option.", flash[:notice]
-    end
-    should "relate category to post (has_and_belongs_to_many)" do
-      category = Factory(:category)
-      @request.env['HTTP_REFERER'] = "/admin/posts/edit/#{@post.id}#categories"
-      assert_difference('category.posts.count') do
-        post :relate, :id => @post.id, :related => { :model => 'Category', :id => category.id, :association_name => 'categories' }
-      end
-      assert_response :redirect
-      assert_redirected_to @request.env['HTTP_REFERER']
-      assert_equal "Post successfully updated.", flash[:notice]
-    end
-  end
-=end
-  context "Views" do
-    context "Index" do
-      setup do
-        get :index
-      end
-      should "render index and validates_presence_of_custom_partials" do
-        assert_match "posts#_index.html.erb", @response.body
-      end
-      should "render_index_and_verify_page_title" do
-        assert_select "title", "Typus &mdash; Posts"
-      end
-      should "render index_and_show_add_entry_link" do
-        assert_select "#sidebar ul" do
-          assert_select "li", "Add New"
-        end
-      end
-    end
-    context "New" do
-      setup do
-        get :new
-      end
-      should "render new and partials_on_new" do
-        assert_match "posts#_new.html.erb", @response.body
-      end
-      should "render new and verify page title" do
-        assert_select "title", "Typus &mdash; Add New Post"
-      end
-    end
-    context "Edit" do
-      setup do
-        get :edit, :id => Factory(:post).id
-      end
-      should "render_edit_and_verify_presence_of_custom_partials" do
-        assert_match "posts#_edit.html.erb", @response.body
-      end
-      should "render_edit_and_verify_page_title" do
-        assert_select "title", "Typus &mdash; Edit Post"
-      end
-    end
-    context "Show" do
-      setup do
-        get :show, :id => Factory(:post).id
-      end
-      should "render_show_and_verify_presence_of_custom_partials" do
-        assert_match "posts#_show.html.erb", @response.body
-      end
-      should "render show and verify page title" do
-        assert_select "title", "Typus &mdash; Show Post"
-      end
-    end
-    should "get_index_and_render_edit_or_show_links" do
-      %w(edit show).each do |action|
-        Typus::Resources.expects(:default_action_on_item).at_least_once.returns(action)
-        get :index
-        Post.all.each do |post|
-          assert_match "/posts/#{action}/#{post.id}", @response.body
-        end
-      end
-    end
-    context "Designer" do
-      setup do
-        designer_sign_in
-      end
-      should "render_index_and_not_show_add_entry_link" do
-        get :index
-        assert_response :success
-        assert_no_match /Add Post/, @response.body
-      end
-    end
-    context "Editor" do
-      setup do
-        editor_sign_in
-      end
-=begin
-      ##
-      # This feature is no longer available. I've to decide if I want to take
-      # it back.
-      #
-      should "get_index_and_render_edit_or_show_links_on_owned_records" do
-        get :index
-        Post.all.each do |post|
-          action = post.owned_by?(@typus_user) ? "edit" : "show"
-          assert_match "/posts/#{action}/#{post.id}", @response.body
-        end
-      end
-=end
-      should "get_index_and_render_edit_or_show_on_only_user_items" do
-        %w(edit show).each do |action|
-          Typus::Resources.stubs(:only_user_items).returns(true)
-          Typus::Resources.stubs(:default_action_on_item).returns(action)
-          get :index
-          Post.all.each do |post|
-            if @typus_user.owns?(post)
-              assert_match "/posts/#{action}/#{post.id}", @response.body
-            else
-              assert_no_match /\/posts\/#{action}\/#{post.id}/, @response.body
-            end
-          end
-        end
-      end
-    end
-  end
-  ##
-  # We are in a View and we want to create a new Post from there to be able
-  # to assign it. There are two cases:
-  #
-  # - We are creating the view.
-  # - We are editing the view.
-  #
-  context "create_with_back_to" do
-    setup do
-      @post = { :title => 'This is another title', :body => 'Body' }
-    end
-    context "when creating an item" do
-      ##
-      # We click on the "Add New" link and we are redirected to:
-      #
-      #     /admin/posts/new
-      #
-      # With a collection of params which will be used to create the
-      # association if everything works as expected.
-      #
-      # Once the association is created we are redirected back to where we
-      # started with a param which selects the Post on the View form.
-      #
-      #     /admin/views/new?post_id=1
-      #
-      # So we end up having a new Post and if we save the form will be
-      # assigned to the view.
-      #
-      should_eventually "create new post and redirect to view" do
-        assert_difference('Post.count') do
-          post :create, :post => @post, :resource => "View"
-        end
-        assert_response :redirect
-        assert_redirected_to "/admin/views/new?post_id=#{Post.last.id}"
-      end
-    end
-    context "when editing an item" do
-      ##
-      # We click on the "Add New" link and we are redirected to:
-      #
-      #     /admin/posts/new
-      #
-      # The important thing here is that we are passing the `resource_id`
-      # because we will assign the newly created Post to the View.
-      #
-      # So we will end up having a new Post assigned to the View.
-      #
-      setup do
-        @view = Factory(:view, :post => nil)
-      end
-      should_eventually "create new post and redirect to view" do
-        assert_difference('Post.count') do
-          post :create, :post => @post, :resource => "View", :resource_id => @view.id
-        end
-        assert_response :redirect
-        assert_redirected_to "/admin/views/edit/#{@view.id}"
-        # Make sure the association is created!
-        assert @view.reload.post
-      end
-    end
-  end
-  context "autocomplete" do
-    setup do
-      25.times { Factory(:post) }
-    end
-    should "work and return a json hash with ten items" do
-      get :autocomplete, { :term => "Post" }
-      assert_response :success
-      assert assigns(:items).size.eql?(20)
-    end
-    should "work and return json hash with one item" do
-      post = Post.first
-      post.update_attributes(:title => "fesplugas")
-      get :autocomplete, :term => "jmeiss"
-      assert assigns(:items).size.eql?(0)
-      get :autocomplete, :term => "fesplugas"
-      assert assigns(:items).size.eql?(1)
-    end
-  end
-end