typus 0.9.17

data/test/helpers/typus_helper_test.rb

@@ -0,0 +1,117 @@
+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 - 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>))
+    self.stubs(:link_to_unless_current).returns(%(<a href="/admin/dashboard">Dashboard</a>))
+
+    output = header
+    expected = <<-HTML
+<h1>#{Typus::Configuration.options[:app_name]}</h1>
+<ul>
+<li><a href="/admin/dashboard">Dashboard</a></li>
+<li><a href="/admin/dashboard">Dashboard</a></li>
+<li><a href="/">View site</a></li>
+</ul>
+    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 }
+
+    self.stubs(:link_to_unless_current).returns(%(<a href="/admin/dashboard">Dashboard</a>))
+
+    output = header
+    expected = <<-HTML
+<h1>#{Typus::Configuration.options[:app_name]}</h1>
+<ul>
+<li><a href="/admin/dashboard">Dashboard</a></li>
+<li><a href="/admin/dashboard">Dashboard</a></li>
+</ul>
+    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,382 @@
+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_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 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')
+
+    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 ), 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.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'#{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 => 'past_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 => 'this_month' }
+    assert_equal expected, TypusUser.build_conditions(params).first
+
+    expected = case ENV['DB']
+               when /postgresql/
+                 "(created_at BETWEEN E'#{Time.new.midnight.last_year.to_s(:db)}' AND E'#{Time.new.midnight.tomorrow.to_s(:db)}')"
+               else
+                 "(created_at BETWEEN '#{Time.new.midnight.last_year.to_s(:db)}' AND '#{Time.new.midnight.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.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.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_nil Post.typus_template('created_at')
+   assert_nil Post.typus_template('unknown')
+
+  end
+
+end