fesplugas-typus 0.9.0

data/test/helpers/typus_helper_test.rb

@@ -0,0 +1,106 @@
+require 'test/helper'
+
+class TypusHelperTest < ActiveSupport::TestCase
+
+  include TypusHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TextHelper
+  include ActionController::UrlWriter
+
+  def test_applications
+    assert true
+  end
+
+  def test_resources
+    assert true
+  end
+
+  def test_typus_block_when_partial_does_not_exist
+    output = typus_block(:resource => 'posts', :location => 'sidebar', :partial => 'pum')
+    assert output.nil?
+  end
+
+  def test_page_title
+    params = {}
+    options = { :app_name => 'whatistypus.com' }
+    Typus::Configuration.stubs(:options).returns(options)
+    output = page_title('custom_action')
+    assert_equal 'whatistypus.com &rsaquo; Custom action', output
+  end
+
+  def test_header_with_root_path
+
+    # Add root named route
+    ActionController::Routing::Routes.add_named_route :root, "/", { :controller => "posts" }
+
+    # ActionView::Helpers::UrlHelper does not support strings, which are returned by named routes
+    # link root_path
+    self.stubs(:link_to).returns(%(<a href="/">View site</a>))
+
+    output = header
+    expected = <<-HTML
+<h1>#{Typus::Configuration.options[:app_name]} <small><a href="/">View site</a></small>
+</h1>
+    HTML
+
+    assert_equal expected, output
+
+  end
+  
+  def test_header_without_root_path
+
+    # Remove root route from list
+    ActionController::Routing::Routes.named_routes.routes.reject! {|key, route| key == :root }
+
+    output = header
+    expected = <<-HTML
+<h1>#{Typus::Configuration.options[:app_name]} </h1>
+    HTML
+
+    assert_equal expected, output
+
+  end
+
+  def test_display_flash_message
+
+    message = { :test => 'This is the message.' }
+
+    output = display_flash_message(message)
+    expected = <<-HTML
+<div id="flash" class="test">
+  <p>This is the message.</p>
+</div>
+    HTML
+
+    assert_equal expected, output
+
+    message = {}
+    output = display_flash_message(message)
+    assert output.nil?
+
+  end
+
+  def test_typus_message
+    output = typus_message('chunky bacon', 'yay')
+    expected = <<-HTML
+<div id="flash" class="yay">
+  <p>chunky bacon</p>
+</div>
+    HTML
+    assert_equal expected, output
+  end
+
+  def test_locales
+
+    options = { :locales => [ [ "English", :en ], [ "Español", :es ] ] }
+    Typus::Configuration.stubs(:options).returns(options)
+
+    output = locales('set_locale')
+    expected = <<-HTML
+<p>Set language to <a href=\"set_locale?locale=en\">english</a>, <a href=\"set_locale?locale=es\">español</a>.</p>
+    HTML
+    assert_equal expected, output
+
+  end
+
+end

data/test/lib/active_record_test.rb

@@ -0,0 +1,372 @@
+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], 
+                       [: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_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 10, Post.typus_options_for(:form_rows)
+    assert_equal 10, 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 10, Asset.typus_options_for(:form_rows)
+    assert_equal 10, Asset.typus_options_for('form_rows')
+
+    assert_equal 10, TypusUser.typus_options_for(:form_rows)
+    assert_equal 10, TypusUser.typus_options_for('form_rows')
+
+  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 ), Post.typus_defaults_for('relationships')
+    assert_equal %w( assets categories ), 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.today.to_s(:db)}' AND E'#{Time.today.tomorrow.to_s(:db)}')"
+               else
+                 "(created_at BETWEEN '#{Time.today.to_s(:db)}' AND '#{Time.today.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'#{6.days.ago.midnight.to_s(:db)}' AND E'#{Time.today.tomorrow.to_s(:db)}')"
+               else
+                 "(created_at BETWEEN '#{6.days.ago.midnight.to_s(:db)}' AND '#{Time.today.tomorrow.to_s(:db)}')"
+               end
+    params = { :created_at => 'past_7_days' }
+    assert_equal expected, TypusUser.build_conditions(params).first
+
+
+    expected = case ENV['DB']
+               when /postgresql/
+                 "(created_at BETWEEN E'#{Time.today.last_month.to_s(:db)}' AND E'#{Time.today.tomorrow.to_s(:db)}')"
+               else
+                 "(created_at BETWEEN '#{Time.today.last_month.to_s(:db)}' AND '#{Time.today.tomorrow.to_s(:db)}')"
+               end
+    params = { :created_at => 'this_month' }
+    assert_equal expected, TypusUser.build_conditions(params).first
+
+    expected = case ENV['DB']
+               when /postgresql/
+                 "(created_at BETWEEN E'#{Time.today.last_year.to_s(:db)}' AND E'#{Time.today.tomorrow.to_s(:db)}')"
+               else
+                 "(created_at BETWEEN '#{Time.today.last_year.to_s(:db)}' AND '#{Time.today.tomorrow.to_s(:db)}')"
+               end
+    params = { :created_at => 'this_year' }
+    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.today.to_s(:db)}' AND E'#{Time.today.tomorrow.to_s(:db)}')"
+               else
+                 "(published_at BETWEEN '#{Time.today.to_s(:db)}' AND '#{Time.today.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.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_template_is_working_properly
+
+   assert_equal 'datepicker', Post.typus_template('published_at')
+   assert_equal 'datepicker', Post.typus_template(:published_at)
+
+   assert_equal nil, Post.typus_template('created_at')
+   assert_equal nil, Post.typus_template('unknown')
+
+  end
+
+end

data/test/lib/configuration_test.rb

@@ -0,0 +1,91 @@
+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.exists?(initializer)
+    assert_equal 'Typus', Typus::Configuration.options[:app_name]
+    assert_equal 'vendor/plugins/typus/test/config/working', Typus::Configuration.options[:config_folder]
+    assert_equal 'admin@example.com', Typus::Configuration.options[:email]
+    assert_equal [ [ "English", :en] ], Typus::Configuration.options[:locales]
+    assert_equal false, Typus::Configuration.options[:recover_password]
+    assert_equal 'admin', Typus::Configuration.options[:root]
+    assert_equal false, Typus::Configuration.options[:ssl]
+    assert_equal 'admin/templates', Typus::Configuration.options[:templates_folder]
+    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.exists?(initializer)
+    assert_equal nil, Typus::Configuration.options[:end_year]
+    assert_equal 10, Typus::Configuration.options[:form_rows]
+    assert_equal true, Typus::Configuration.options[:icon_on_boolean]
+    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 15, Typus::Configuration.options[:per_page]
+    assert_equal 5, Typus::Configuration.options[:sidebar_selector]
+    assert_equal 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) }
+    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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,82 @@
+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, :admin_set_locale ]
+
+    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', 'set_locale' ]
+
+    actions.each { |a| assert_routing "/admin/#{a}", :controller => 'typus', :action => a }
+
+  end
+
+=begin
+
+  # FIXME
+
+  def test_should_verify_generated_routes_for_resource_controller
+    assert_routing '/admin/watch_dog', :controller => 'admin/watch_dog', :action => 'index'
+    assert_routing '/admin/watch_dog/cleanup', { :controller => 'admin/watch_dog', :action => 'cleanup' }
+  end
+
+=end
+
+end

data/test/lib/string_test.rb

@@ -0,0 +1,25 @@
+require 'test/helper'
+
+class StringTest < ActiveSupport::TestCase
+
+  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