typus 0.9.39 → 1.0.0.pre

data/test/lib/active_record_test.rb

@@ -1,377 +0,0 @@
-require 'test/helper'
-
-class ActiveRecordTest < ActiveSupport::TestCase
-
-  def test_should_verify_model_fields_is_an_instance_of_active_support_ordered_hash
-    assert TypusUser.model_fields.instance_of?(ActiveSupport::OrderedHash)
-  end
-
-  def test_should_return_model_fields_for_typus_user
-    expected_fields = [[:id, :integer], 
-                       [:first_name, :string], 
-                       [:last_name, :string], 
-                       [:role, :string], 
-                       [:email, :string], 
-                       [:status, :boolean], 
-                       [:token, :string], 
-                       [:salt, :string], 
-                       [:crypted_password, :string], 
-                       [:preferences, :string], 
-                       [:created_at, :datetime], 
-                       [:updated_at, :datetime]]
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.model_fields.keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.model_fields.values
-  end
-
-  def test_should_return_model_fields_for_post
-    expected_fields = [[:id, :integer],
-                       [:title, :string],
-                       [:body, :text],
-                       [:status, :boolean],
-                       [:favorite_comment_id, :integer],
-                       [:created_at, :datetime],
-                       [:updated_at, :datetime],
-                       [:published_at, :datetime], 
-                       [:typus_user_id, :integer]]
-    assert_equal expected_fields.map { |i| i.first }, Post.model_fields.keys
-    assert_equal expected_fields.map { |i| i.last }, Post.model_fields.values
-  end
-
-  def test_should_verify_model_relationships_is_an_instance_of_active_support_ordered_hash
-    assert TypusUser.model_relationships.instance_of?(ActiveSupport::OrderedHash)
-  end
-
-  def test_should_return_model_relationships_for_post
-    expected = [[:comments, :has_many],
-                [:categories, :has_and_belongs_to_many],
-                [:user, nil],
-                [:assets, :has_many]]
-    expected.each do |i|
-      assert_equal i.last, Post.model_relationships[i.first]
-    end
-  end
-
-  def test_should_return_description_of_a_model
-    assert TypusUser.respond_to?(:typus_description)
-    assert_equal "System Users Administration", TypusUser.typus_description
-  end
-
-  def test_should_return_typus_fields_for_list_for_typus_user
-    expected_fields = [['email', :string], 
-                       ['role', :selector], 
-                       ['status', :boolean]]
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for('list').keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for('list').values
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for(:list).keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for(:list).values
-  end
-
-  def test_should_return_typus_fields_for_list_for_post
-    expected_fields = [['title', :string],
-                       ['created_at', :datetime],
-                       ['status', :selector]]
-    assert_equal expected_fields.map { |i| i.first }, Post.typus_fields_for('list').keys
-    assert_equal expected_fields.map { |i| i.last }, Post.typus_fields_for('list').values
-    assert_equal expected_fields.map { |i| i.first }, Post.typus_fields_for(:list).keys
-    assert_equal expected_fields.map { |i| i.last }, Post.typus_fields_for(:list).values
-  end
-
-  def test_should_return_typus_fields_for_form_for_typus_user
-    expected_fields = [['first_name', :string], 
-                       ['last_name', :string], 
-                       ['role', :selector], 
-                       ['email', :string], 
-                       ['password', :password], 
-                       ['password_confirmation', :password]]
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for('form').keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for('form').values
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for(:form).keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for(:form).values
-  end
-
-  def test_should_return_typus_fields_for_a_model_without_configuration
-    expected_fields = []
-    klass = Class.new(ActiveRecord::Base)
-    assert_equal expected_fields, klass.typus_fields_for(:form)
-    assert_equal expected_fields, klass.typus_fields_for(:list)
-  end
-
-  def test_should_return_typus_fields_for_relationship_for_typus_user
-    expected_fields = [['email', :string], 
-                       ['role', :selector], 
-                       ['status', :boolean]]
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for('relationship').keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for('relationship').values
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for(:relationship).keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for(:relationship).values
-  end
-
-  def test_should_return_all_fields_for_undefined_field_type_on_typus_user
-    expected_fields = [['email', :string], 
-                       ['role', :selector], 
-                       ['status', :boolean]]
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for('undefined').keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for('undefined').values
-    assert_equal expected_fields.map { |i| i.first }, TypusUser.typus_fields_for(:undefined).keys
-    assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for(:undefined).values
-  end
-
-  def test_should_return_filters_for_typus_user
-    expected = [['status', :boolean], 
-                ['role', :string]]
-    assert_equal 'status, role', Typus::Configuration.config['TypusUser']['filters']
-    assert_equal expected.map { |i| i.first }, TypusUser.typus_filters.keys
-    assert_equal expected.map { |i| i.last }, TypusUser.typus_filters.values
-  end
-
-  def test_should_return_post_typus_filters
-    expected = [['status', :boolean], 
-                ['created_at', :datetime], 
-                ['user', nil], 
-                ['user_id', nil]]
-    assert_equal expected.map { |i| i.first }.join(', '), Typus::Configuration.config['Post']['filters']
-    assert_equal expected.map { |i| i.first }, Post.typus_filters.keys
-    assert_equal expected.map { |i| i.last }, Post.typus_filters.values
-  end
-
-  def test_should_return_actions_on_list_for_typus_user
-    assert TypusUser.typus_actions_for('list').empty?
-    assert TypusUser.typus_actions_for(:list).empty?
-  end
-
-  def test_should_return_post_actions_on_index
-    assert_equal %w( cleanup ), Post.typus_actions_for('index')
-    assert_equal %w( cleanup ), Post.typus_actions_for(:index)
-  end
-
-  def test_should_return_post_actions_on_edit
-    assert_equal %w( send_as_newsletter preview ), Post.typus_actions_for('edit')
-    assert_equal %w( send_as_newsletter preview ), Post.typus_actions_for(:edit)
-  end
-
-  def test_should_return_field_options_for_post
-    assert_equal [ :status ], Post.typus_field_options_for('selectors')
-    assert_equal [ :status ], Post.typus_field_options_for(:selectors)
-    assert_equal [ :permalink ], Post.typus_field_options_for('read_only')
-    assert_equal [ :permalink ], Post.typus_field_options_for(:read_only)
-    assert_equal [ :created_at ], Post.typus_field_options_for('auto_generated')
-    assert_equal [ :created_at ], Post.typus_field_options_for(:auto_generated)
-  end
-
-  def test_should_return_options_for_post_and_page
-
-    assert_equal 15, Post.typus_options_for(:form_rows)
-    assert_equal 15, Post.typus_options_for('form_rows')
-
-    assert_equal 25, Page.typus_options_for(:form_rows)
-    assert_equal 25, Page.typus_options_for('form_rows')
-
-    assert_equal 15, Asset.typus_options_for(:form_rows)
-    assert_equal 15, Asset.typus_options_for('form_rows')
-
-    assert_equal 15, TypusUser.typus_options_for(:form_rows)
-    assert_equal 15, TypusUser.typus_options_for('form_rows')
-
-    assert Page.typus_options_for(:on_header)
-    assert !TypusUser.typus_options_for(:on_header)
-
-    assert_nil TypusUser.typus_options_for(:unexisting)
-
-  end
-
-  def test_should_verify_typus_boolean_is_an_instance_of_active_support_ordered_hash
-    assert TypusUser.typus_boolean.instance_of?(ActiveSupport::OrderedHash)
-  end
-
-  def test_should_return_booleans_for_typus_users
-    assert_equal [ :true, :false ], TypusUser.typus_boolean('status').keys
-    assert_equal [ "Active", "Inactive" ], TypusUser.typus_boolean('status').values
-    assert_equal [ :true, :false ], TypusUser.typus_boolean(:status).keys
-    assert_equal [ "Active", "Inactive" ], TypusUser.typus_boolean(:status).values
-  end
-
-  def test_should_return_default_booleans_for_typus_users
-    assert_equal [ :true, :false ], TypusUser.typus_boolean.keys
-    assert_equal [ "True", "False" ], TypusUser.typus_boolean.values
-  end
-
-  def test_should_return_booleans_for_post
-    assert_equal [ :true, :false ], Post.typus_boolean('status').keys
-    assert_equal [ "True", "False" ], Post.typus_boolean('status').values
-    assert_equal [ :true, :false ], Post.typus_boolean(:status).keys
-    assert_equal [ "True", "False" ], Post.typus_boolean(:status).values
-  end
-
-  def test_should_return_date_formats_for_post
-    assert_equal :post_short, Post.typus_date_format('created_at')
-    assert_equal :post_short, Post.typus_date_format(:created_at)
-    assert_equal :db, Post.typus_date_format
-    assert_equal :db, Post.typus_date_format('unknown')
-    assert_equal :db, Post.typus_date_format(:unknown)
-  end
-
-  def test_should_return_defaults_for_post
-    assert_equal %w( title ), Post.typus_defaults_for('search')
-    assert_equal %w( title ), Post.typus_defaults_for(:search)
-    assert_equal %w( title -created_at ), Post.typus_defaults_for('order_by')
-    assert_equal %w( title -created_at ), Post.typus_defaults_for(:order_by)
-  end
-
-  def test_should_return_relationships_for_post
-    assert_equal %w( assets categories comments views ), Post.typus_defaults_for('relationships')
-    assert_equal %w( assets categories comments views ), Post.typus_defaults_for(:relationships)
-    assert !Post.typus_defaults_for('relationships').empty?
-    assert !Post.typus_defaults_for(:relationships).empty?
-  end
-
-  def test_should_return_order_by_for_model
-    assert_equal "posts.title ASC, posts.created_at DESC", Post.typus_order_by
-    assert_equal %w( title -created_at ), Post.typus_defaults_for('order_by')
-    assert_equal %w( title -created_at ), Post.typus_defaults_for(:order_by)
-  end
-
-  def test_should_return_sql_conditions_on_search_for_typus_user
-    expected = "(LOWER(first_name) LIKE '%francesc%' OR LOWER(last_name) LIKE '%francesc%' OR LOWER(email) LIKE '%francesc%' OR LOWER(role) LIKE '%francesc%')"
-    params = { :search => 'francesc' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-    params = { :search => 'Francesc' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-  end
-
-  def test_should_return_sql_conditions_on_search_and_filter_for_typus_user
-
-    case ENV['DB']
-    when /mysql/
-      boolean_true = "(`typus_users`.`status` = 1)"
-      boolean_false = "(`typus_users`.`status` = 0)"
-    else
-      boolean_true = "(\"typus_users\".\"status\" = 't')"
-      boolean_false = "(\"typus_users\".\"status\" = 'f')"
-    end
-
-    expected = "((LOWER(first_name) LIKE '%francesc%' OR LOWER(last_name) LIKE '%francesc%' OR LOWER(email) LIKE '%francesc%' OR LOWER(role) LIKE '%francesc%')) AND #{boolean_true}"
-    params = { :search => 'francesc', :status => 'true' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-    params = { :search => 'francesc', :status => 'false' }
-    assert_match /#{boolean_false}/, TypusUser.build_conditions(params).first
-
-  end
-
-  def test_should_return_sql_conditions_on_filtering_typus_users_by_status
-
-    case ENV['DB']
-    when /mysql/
-      boolean_true = "(`typus_users`.`status` = 1)"
-      boolean_false = "(`typus_users`.`status` = 0)"
-    else
-      boolean_true = "(\"typus_users\".\"status\" = 't')"
-      boolean_false = "(\"typus_users\".\"status\" = 'f')"
-    end
-
-    params = { :status => 'true' }
-    assert_equal boolean_true, TypusUser.build_conditions(params).first
-    params = { :status => 'false' }
-    assert_equal boolean_false, TypusUser.build_conditions(params).first
-
-  end
-
-  def test_should_return_sql_conditions_on_filtering_typus_users_by_created_at
-
-    expected = case ENV['DB']
-               when /postgresql/
-                 "(created_at BETWEEN E'#{Time.new.midnight.to_s(:db)}' AND E'#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               else
-                 "(created_at BETWEEN '#{Time.new.midnight.to_s(:db)}' AND '#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               end
-    params = { :created_at => 'today' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-
-    expected = case ENV['DB']
-               when /postgresql/
-                 "(created_at BETWEEN E'#{3.days.ago.midnight.to_s(:db)}' AND E'#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               else
-                 "(created_at BETWEEN '#{3.days.ago.midnight.to_s(:db)}' AND '#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               end
-    params = { :created_at => 'last_few_days' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-
-    expected = case ENV['DB']
-               when /postgresql/
-                 "(created_at BETWEEN E'#{6.days.ago.midnight.to_s(:db)}' AND E'#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               else
-                 "(created_at BETWEEN '#{6.days.ago.midnight.to_s(:db)}' AND '#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               end
-    params = { :created_at => 'last_7_days' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-
-
-    expected = case ENV['DB']
-               when /postgresql/
-                 "(created_at BETWEEN E'#{Time.new.midnight.last_month.to_s(:db)}' AND E'#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               else
-                 "(created_at BETWEEN '#{Time.new.midnight.last_month.to_s(:db)}' AND '#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               end
-    params = { :created_at => 'last_30_days' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-
-  end
-
-  def test_should_return_sql_conditions_on_filtering_posts_by_published_at
-    expected = case ENV['DB']
-               when /postgresql/
-                 "(published_at BETWEEN E'#{Time.new.midnight.to_s(:db)}' AND E'#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               else
-                 "(published_at BETWEEN '#{Time.new.midnight.to_s(:db)}' AND '#{Time.new.midnight.tomorrow.to_s(:db)}')"
-               end
-    params = { :published_at => 'today' }
-    assert_equal expected, Post.build_conditions(params).first
-  end
-
-  def test_should_return_sql_conditions_on_filtering_posts_by_string
-    expected = case ENV['DB']
-               when /postgresql/
-                 "(\"typus_users\".\"role\" = E'admin')"
-               when /mysql/
-                 "(`typus_users`.`role` = 'admin')"
-               else
-                 "(\"typus_users\".\"role\" = 'admin')"
-               end
-    params = { :role => 'admin' }
-    assert_equal expected, TypusUser.build_conditions(params).first
-  end
-
-  def test_should_verify_previous_and_next
-    assert TypusUser.instance_methods.map { |i| i.to_sym }.include?(:previous_and_next)
-    assert typus_users(:admin).previous_and_next.kind_of?(Array)
-  end
-
-  def test_should_verify_previous_and_next_works_without_conditions
-    expected = [ typus_users(:admin), typus_users(:disabled_user) ]
-    assert_equal expected, typus_users(:editor).previous_and_next
-  end
-
-  def test_should_verify_previous_and_next_works_with_conditions
-    expected = [ typus_users(:editor), typus_users(:removed_role) ]
-    conditions = { 'status' => 'true' }
-    assert_equal expected, typus_users(:designer).previous_and_next(conditions)
-  end
-
-  def test_should_verify_typus_name_is_working_properly
-
-    assert Category.new.respond_to?(:name)
-    assert_equal 'First Category', categories(:first).typus_name
-
-    assert !Page.new.respond_to?(:name)
-    assert_equal 'Page#1', pages(:published).typus_name
-
-    assert Comment.new.respond_to?(:name)
-    assert_equal "John", comments(:first).typus_name
-
-  end
-
-  def test_should_verify_typus_user_id
-    assert Post.typus_user_id?
-    assert !TypusUser.typus_user_id?
-  end
-
-end

data/test/lib/configuration_test.rb

@@ -1,95 +0,0 @@
-require 'test/helper'
-
-class ConfigurationTest < ActiveSupport::TestCase
-
-  def test_should_verify_configuration_responds_to_options
-    assert Typus::Configuration.respond_to?(:options)
-  end
-
-  def test_should_verify_application_wide_configuration_options
-    initializer = "#{Rails.root}/config/initializers/typus.rb"
-    return if File.exist?(initializer)
-    assert_equal 'Typus', Typus::Configuration.options[:app_name]
-    assert_equal 'vendor/plugins/typus/test/config/working', Typus::Configuration.options[:config_folder]
-    assert_equal :en, Typus::Configuration.options[:default_locale]
-    assert_equal 'admin@example.com', Typus::Configuration.options[:email]
-    assert_equal :typus_preview, Typus::Configuration.options[:file_preview]
-    assert_equal :typus_thumbnail, Typus::Configuration.options[:file_thumbnail]
-    assert_equal false, Typus::Configuration.options[:recover_password]
-    assert_equal 'typus_users', Typus::Configuration.options[:relationship]
-    assert_equal 'admin', Typus::Configuration.options[:root]
-    assert_equal false, Typus::Configuration.options[:ssl]
-    assert_equal 'TypusUser', Typus::Configuration.options[:user_class_name]
-    assert_equal 'typus_user_id', Typus::Configuration.options[:user_fk]
-  end
-
-  def test_should_verify_model_configuration_options
-    initializer = "#{Rails.root}/config/initializers/typus.rb"
-    return if File.exist?(initializer)
-    assert_equal 'edit', Typus::Configuration.options[:default_action_on_item]
-    assert_nil Typus::Configuration.options[:end_year]
-    assert_equal 15, Typus::Configuration.options[:form_rows]
-    assert_equal false, Typus::Configuration.options[:index_after_save]
-    assert_equal 5, Typus::Configuration.options[:minute_step]
-    assert_equal 'nil', Typus::Configuration.options[:nil]
-    assert_equal false, Typus::Configuration.options[:on_header]
-    assert_equal false, Typus::Configuration.options[:only_user_items]
-    assert_equal 15, Typus::Configuration.options[:per_page]
-    assert_equal 5, Typus::Configuration.options[:sidebar_selector]
-    assert_nil Typus::Configuration.options[:start_year]
-    assert_equal true, Typus::Configuration.options[:toggle]
-  end
-
-  def test_should_verify_typus_roles_is_loaded
-    assert Typus::Configuration.respond_to?(:roles!)
-    assert Typus::Configuration.roles!.kind_of?(Hash)
-  end
-
-  def test_should_verify_typus_config_file_is_loaded
-    assert Typus::Configuration.respond_to?(:config!)
-    assert Typus::Configuration.config!.kind_of?(Hash)
-  end
-
-  def test_should_load_configuration_files_from_config_broken
-    options = { :config_folder => 'vendor/plugins/typus/test/config/broken' }
-    Typus::Configuration.stubs(:options).returns(options)
-    assert_not_equal Hash.new, Typus::Configuration.roles!
-    assert_not_equal Hash.new, Typus::Configuration.config!
-  end
-
-  def test_should_load_configuration_files_from_config_empty
-    options = { :config_folder => 'vendor/plugins/typus/test/config/empty' }
-    Typus::Configuration.stubs(:options).returns(options)
-    assert_equal Hash.new, Typus::Configuration.roles!
-    assert_equal Hash.new, Typus::Configuration.config!
-  end
-
-  def test_should_load_configuration_files_from_config_ordered
-    options = { :config_folder => 'vendor/plugins/typus/test/config/ordered' }
-    Typus::Configuration.stubs(:options).returns(options)
-    files = Dir["#{Rails.root}/#{Typus::Configuration.options[:config_folder]}/*_roles.yml"]
-    expected = files.collect { |file| File.basename(file) }.sort
-    assert_equal expected, ['001_roles.yml', '002_roles.yml']
-    expected = { 'admin' => { 'categories' => 'read' } }
-    assert_equal expected, Typus::Configuration.roles!
-  end
-
-  def test_should_load_configuration_files_from_config_unordered
-    options = { :config_folder => 'vendor/plugins/typus/test/config/unordered' }
-    Typus::Configuration.stubs(:options).returns(options)
-    files = Dir["#{Rails.root}/#{Typus::Configuration.options[:config_folder]}/*_roles.yml"]
-    expected = files.collect { |file| File.basename(file) }
-    assert_equal expected, ['app_one_roles.yml', 'app_two_roles.yml']
-    expected = { 'admin' => { 'categories' => 'read, update' } }
-    assert_equal expected, Typus::Configuration.roles!
-  end
-
-  def test_should_load_configuration_files_from_config_default
-    options = { :config_folder => 'vendor/plugins/typus/test/config/default' }
-    Typus::Configuration.stubs(:options).returns(options)
-    assert_not_equal Hash.new, Typus::Configuration.roles!
-    assert_not_equal Hash.new, Typus::Configuration.config!
-    assert Typus.resources.empty?
-  end
-
-end

data/test/lib/hash_test.rb

@@ -1,11 +0,0 @@
-require 'test/helper'
-
-class HashTest < ActiveSupport::TestCase
-
-  def test_should_verify_compact
-    hash = { 'a' => '', 'b'=> nil, 'c' => 'hello' }
-    hash_compacted = { 'c' => 'hello' }
-    assert_equal hash_compacted, hash.compact
-  end
-
-end

data/test/lib/routes_test.rb

@@ -1,71 +0,0 @@
-require 'test/helper'
-
-class RoutesTest < ActiveSupport::TestCase
-
-  include ActionController::TestCase::Assertions
-
-  def test_should_verify_admin_named_routes
-
-    routes = ActionController::Routing::Routes.named_routes.routes.keys
-
-    expected = [ :admin_sign_up, :admin_sign_in, :admin_sign_out, 
-                 :admin_recover_password, :admin_reset_password, 
-                 :admin_dashboard, 
-                 :admin_quick_edit ]
-
-    expected.each { |route| assert routes.include?(route) }
-
-  end
-
-  def test_should_verify_admin_named_routes_for_typus_users
-
-    routes = ActionController::Routing::Routes.named_routes.routes.keys
-
-    expected = [ :admin_typus_users, 
-                 :admin_typus_user ]
-
-    expected.each { |route| assert !routes.include?(route) }
-
-    expected = [ :relate_admin_typus_user,
-                 :unrelate_admin_typus_user ]
-
-    expected.each { |route| assert !routes.include?(route) }
-
-  end
-
-  def test_should_verify_default_admin_named_routes_for_posts
-
-    routes = ActionController::Routing::Routes.named_routes.routes.keys
-
-    expected = [ :admin_posts, 
-                 :admin_post ]
-
-    expected.each { |route| assert !routes.include?(route) }
-
-  end
-
-  def test_should_verify_custom_admin_named_routes_for_posts
-
-    routes = ActionController::Routing::Routes.named_routes.routes.keys
-
-    expected = [ :cleanup_admin_posts, 
-                 :send_as_newsletter_admin_post, 
-                 :preview_admin_post ]
-
-    expected.each { |route| assert !routes.include?(route) }
-
-  end
-
-  def test_should_verify_generated_routes_for_typus_controller
-
-    assert_routing '/admin', :controller => 'typus', :action => 'dashboard'
-
-    actions = [ 'sign_up', 'sign_in', 'sign_out', 
-                'recover_password', 'reset_password', 
-                'quick_edit' ]
-
-    actions.each { |a| assert_routing "/admin/#{a}", :controller => 'typus', :action => a }
-
-  end
-
-end

data/test/lib/string_test.rb

@@ -1,55 +0,0 @@
-require 'test/helper'
-
-class StringTest < ActiveSupport::TestCase
-
-  def test_extract_controller
-
-    assert_equal ['posts'], 'admin/posts'.extract_controller
-    assert_equal ['typus_users'], 'admin/typus_users'.extract_controller
-    assert_equal ['delayed', 'jobs'], 'admin/delayed/jobs'.extract_controller
-
-    assert_equal ['posts'], 'typus/posts'.extract_controller('typus')
-    assert_equal ['typus_users'], 'typus/typus_users'.extract_controller('typus')
-    assert_equal ['delayed', 'tasks'], 'typus/delayed/tasks'.extract_controller('typus')
-
-  end
-
-  def test_extract_resource
-    assert_equal 'posts', 'admin/posts'.extract_resource
-    assert_equal 'typus_users', 'admin/typus_users'.extract_resource
-    assert_equal 'delayed/tasks', 'admin/delayed/tasks'.extract_resource
-  end
-
-  def test_extract_class
-    assert_equal Post, 'admin/posts'.extract_class
-    assert_equal TypusUser, 'admin/typus_users'.extract_class
-    assert_equal Delayed::Task, 'admin/delayed/tasks'.extract_class
-  end
-
-  def test_extract_human_name
-    assert_equal 'Post', 'admin/posts'.extract_human_name
-    assert_equal 'Typus user', 'admin/typus_users'.extract_human_name
-    assert_equal 'Delayed task', 'admin/delayed/tasks'.extract_human_name
-  end
-
-  def test_should_return_post_actions_for_index
-    assert_equal %w( cleanup ), 'Post'.typus_actions_for('index')
-    assert_equal %w( cleanup ), 'Post'.typus_actions_for(:index)
-  end
-
-  def test_should_return_post_actions_for_edit
-    assert_equal %w( send_as_newsletter preview ), 'Post'.typus_actions_for('edit')
-    assert_equal %w( send_as_newsletter preview ), 'Post'.typus_actions_for(:edit)
-  end
-
-  def test_should_verify_typus_actions_for_unexisting_returns_is_empty
-    assert 'TypusUser'.typus_actions_for('unexisting').empty?
-    assert 'TypusUser'.typus_actions_for(:unexisting).empty?
-  end
-
-  def test_should_verify_typus_actions_for_index_returns_an_array
-    assert 'Post'.typus_actions_for('index').kind_of?(Array)
-    assert 'Post'.typus_actions_for(:index).kind_of?(Array)
-  end
-
-end

data/test/unit/typus_mailer_test.rb

@@ -1,29 +0,0 @@
-require 'test/helper'
-
-class TypusMailerTest < ActiveSupport::TestCase
-
-  def setup
-    @user = typus_users(:admin)
-    ActionMailer::Base.default_url_options[:host] = 'test.host'
-    @response = TypusMailer.deliver_reset_password_link(@user)
-  end
-
-  def test_should_verify_email_from_is_defined_by_typus_options
-    assert_equal [ Typus::Configuration.options[:email] ], @response.from
-  end
-
-  def test_should_verify_email_to_is_typus_user_email
-    assert_equal [ @user.email ], @response.to
-  end
-
-  def test_should_verify_email_subject
-    expected = "[#{Typus::Configuration.options[:app_name]}] Reset password"
-    assert_equal expected, @response.subject
-  end
-
-  def test_should_verify_email_contains_reset_password_link_with_token
-    expected = "http://test.host/admin/reset_password?token=1A2B3C4D5E6F"
-    assert_match expected, @response.body
-  end
-
-end

data/test/unit/typus_test.rb

@@ -1,17 +0,0 @@
-require 'test/helper'
-
-class TypusTest < ActiveSupport::TestCase
-
-  def test_should_verify_models
-    models = [ Category, Comment, Post, TypusUser ]
-    models.each { |m| assert m.superclass.equal?(ActiveRecord::Base) }
-  end
-
-  def test_should_verify_fixtures_are_loaded
-    assert_equal 3, Category.count
-    assert_equal 4, Comment.count
-    assert_equal 4, Post.count
-    assert_equal 5, TypusUser.count
-  end
-
-end

data/test/vendor/active_record_test.rb

@@ -1,18 +0,0 @@
-require 'test/helper'
-
-class ActiveRecordTest < ActiveSupport::TestCase
-
-  def test_should_verify_to_dom
-
-    assert_equal "typus_user_new", TypusUser.new.to_dom
-
-    typus_user = typus_users(:admin)
-    assert_equal "typus_user_#{typus_user.id}", typus_user.to_dom
-
-    assert_equal "prefix_typus_user_#{typus_user.id}", typus_user.to_dom(:prefix => 'prefix')
-    assert_equal "typus_user_#{typus_user.id}_suffix", typus_user.to_dom(:suffix => 'suffix')
-    assert_equal "prefix_typus_user_#{typus_user.id}_suffix", typus_user.to_dom(:prefix => 'prefix', :suffix => 'suffix')
-
-  end
-
-end