typus 3.0.2 → 3.0.4

data/test/integration/login_test.rb

@@ -1,13 +0,0 @@
-require 'integration_test_helper'
-
-class LoginTest < ActionController::IntegrationTest
-
-  feature "Admin goes to login page" do
-
-    scenario "views page" do
-      visit '/admin'
-    end
-
-  end
-
-end

data/test/integration_test_helper.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-require 'capybara/rails'
-
-module ActionController
-
-  class IntegrationTest
-    include Capybara
-  end
-
-end
-
-module Shoulda
-
-  module ClassMethods
-
-    alias :feature :context
-    alias :scenario :should
-
-  end
-
-end

data/test/lib/support/active_record_test.rb

@@ -1,86 +0,0 @@
-require "test_helper"
-
-class ActiveRecordTest < ActiveSupport::TestCase
-
-  context "mapping" do
-
-    context "with an array" do
-
-      setup do
-        Post.send(:remove_const, :STATUS)
-        Post::STATUS = %w(pending published unpublished)
-      end
-
-      should "verify" do
-        post = Factory(:post)
-        assert_equal "published", post.mapping(:status)
-        post = Factory(:post, :status => "unpublished")
-        assert_equal "unpublished", post.mapping(:status)
-      end
-
-    end
-
-    context "with a two dimension array" do
-
-      setup do
-        Post.send(:remove_const, :STATUS)
-        Post::STATUS = [["Publicado", "published"], ["Pendiente", "pending"], ["No publicado", "unpublished"]]
-      end
-
-      should "verify" do
-        post = Factory(:post)
-        assert_equal "Publicado", post.mapping(:status)
-        post = Factory(:post, :status => "unpublished")
-        assert_equal "No publicado", post.mapping(:status)
-      end
-
-    end
-
-    context "with a hash" do
-
-      setup do
-        Post.send(:remove_const, :STATUS)
-        Post::STATUS = { "Pending - Hash" => "pending", "Published - Hash" => "published", "Not Published - Hash" => "unpublished" }
-      end
-
-      should "verify" do
-        page = Factory(:post)
-        assert_equal "Published - Hash", page.mapping(:status)
-        page = Factory(:post, :status => "unpublished")
-        assert_equal "Not Published - Hash", page.mapping(:status)
-      end
-
-    end
-
-  end
-
-  context "to_label" do
-
-    should "return email as is an alias for to_label on TypusUser" do
-      assert_equal "admin@example.com", Factory(:typus_user).to_label
-    end
-
-    should "return name for Category" do
-      category = Factory(:category)
-      assert_match category.name, category.to_label
-    end
-
-    should "return default Model#id" do
-      assert_match /Post#/, Factory(:post).to_label
-    end
-
-  end
-
-  context "to_resource" do
-
-    should "work for models" do
-      assert_equal "typus_users", TypusUser.to_resource
-    end
-
-    should "work for namespaced models" do
-      assert_equal "delayed/tasks", Delayed::Task.to_resource
-    end
-
-  end
-
-end

data/test/lib/support/array_test.rb

@@ -1,11 +0,0 @@
-require "test_helper"
-
-class ArrayTest < ActiveSupport::TestCase
-
-  should "verify to_hash_with" do
-    keys, values = %w(a b c), %w(1 2 3)
-    expected = { "a" => "1", "b" => "2", "c" => "3" }
-    assert_equal expected, keys.to_hash_with(values)
-  end
-
-end

data/test/lib/support/hash_test.rb

@@ -1,11 +0,0 @@
-require "test_helper"
-
-class HashTest < ActiveSupport::TestCase
-
-  should "verify Hash#compact" do
-    hash = { "a" => "", "b" => nil, "c" => "hello" }
-    hash_compacted = { "c" => "hello" }
-    assert_equal hash_compacted, hash.compact
-  end
-
-end

data/test/lib/support/string_test.rb

@@ -1,39 +0,0 @@
-require "test_helper"
-
-class StringTest < ActiveSupport::TestCase
-
-  should "extract_settings" do
-    assert_equal %w( a b c ), "a, b, c".extract_settings
-    assert_equal %w( a b c ), " a  , b,  c ".extract_settings
-  end
-
-  context "remove_prefix" do
-
-    should "remove admin by default" do
-      assert_equal "posts", "admin/posts".remove_prefix
-      assert_equal "typus_users", "admin/typus_users".remove_prefix
-      assert_equal "delayed/jobs", "admin/delayed/jobs".remove_prefix
-    end
-
-    should "remove what we want to" do
-      assert_equal "posts", "typus/posts".remove_prefix("typus/")
-      assert_equal "typus_users", "typus/typus_users".remove_prefix("typus/")
-      assert_equal "delayed/tasks", "typus/delayed/tasks".remove_prefix("typus/")
-    end
-
-  end
-
-  context "extract_class" do
-
-    should "work for models" do
-      assert_equal Post, "admin/posts".extract_class
-      assert_equal TypusUser, "admin/typus_users".extract_class
-    end
-
-    should "work for namespaced models" do
-      assert_equal Delayed::Task, "admin/delayed/tasks".extract_class
-    end
-
-  end
-
-end

data/test/lib/typus/active_record_test.rb

@@ -1,451 +0,0 @@
-require "test_helper"
-
-class ActiveRecordTest < ActiveSupport::TestCase
-
-  context "model_fields" do
-
-    should "be an ActiveSupport::OrderedHash" do
-      assert TypusUser.model_fields.instance_of?(ActiveSupport::OrderedHash)
-    end
-
-    should "verify TypusUser model_fields" do
-      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
-
-    should "verify Post model_fields" do
-      expected_fields = [[:id, :integer],
-                         [:title, :string],
-                         [:body, :text],
-                         [:status, :string],
-                         [: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
-
-  end
-
-  context "model_relationships" do
-
-    should "be an ActiveSupport::OrderedHash" do
-      assert TypusUser.model_relationships.instance_of?(ActiveSupport::OrderedHash)
-    end
-
-    should "verify Post model_relationships" do
-      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
-
-  end
-
-  context "typus_description" do
-
-    should "return the description of a model" do
-      assert_equal "System Users Administration", TypusUser.typus_description
-    end
-
-  end
-
-  context "typus_fields_for" do
-
-    should "accept strings" do
-      assert_equal %w( email role status ), TypusUser.typus_fields_for("list").keys
-    end
-
-    should "accept symbols" do
-      assert_equal %w( email role status ), TypusUser.typus_fields_for(:list).keys
-    end
-
-    should "return list fields for TypusUser" do
-      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
-    end
-
-    should "return form fields for TypusUser" do
-      expected_fields = [["first_name", :string],
-                         ["last_name", :string],
-                         ["role", :selector],
-                         ["email", :string],
-                         ["password", :password],
-                         ["password_confirmation", :password],
-                         ["language", :selector]]
-      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
-
-    should "return form fields for Picture" do
-      expected_fields = [["title", :string],
-                         ["picture", :file]]
-      assert_equal expected_fields.map { |i| i.first }, Picture.typus_fields_for(:form).keys
-      assert_equal expected_fields.map { |i| i.last }, Picture.typus_fields_for(:form).values
-    end
-
-    should "return form fields for a Model without configuration" do
-      assert Class.new(ActiveRecord::Base).typus_fields_for(:form).empty?
-    end
-
-    should "return relationship fields for TypusUser" do
-      assert_equal %w( first_name last_name role email language), TypusUser.typus_fields_for(:relationship).keys
-    end
-
-    should "return undefined fields for TypusUser" do
-      assert_equal %w( first_name last_name role email language), TypusUser.typus_fields_for(:undefined).keys
-    end
-
-  end
-
-  context "typus_filters" do
-
-    should "return filters for TypusUser" do
-      expected = [["status", :boolean], ["role", :string]]
-
-      assert_equal expected.map { |i| i.first }.join(", "), 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
-
-    should "return filters for Post" do
-      expected = [["status", :string], ["created_at", :datetime]]
-      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
-
-  end
-
-  context "typus_actions_on" do
-
-    should "accept strings" do
-      assert_equal %w( cleanup ), Post.typus_actions_on("index")
-    end
-
-    should "accept symbols" do
-      assert_equal %w( cleanup ), Post.typus_actions_on(:index)
-    end
-
-    should "return actions on list for TypusUser" do
-      assert TypusUser.typus_actions_on(:list).empty?
-    end
-
-    should "return actions on edit for Post" do
-      assert_equal %w( send_as_newsletter preview ), Post.typus_actions_on(:edit)
-    end
-
-  end
-
-  context "typus_options_for" do
-
-    should "accept strings" do
-      assert_equal 15, Post.typus_options_for("form_rows")
-    end
-
-    should "accept symbols" do
-      assert_equal 15, Post.typus_options_for(:form_rows)
-    end
-
-    should "return nil when options do not exist" do
-      assert_nil TypusUser.typus_options_for(:unexisting)
-    end
-
-    should "return options for Post" do
-      assert_equal 15, Post.typus_options_for(:form_rows)
-    end
-
-    should "return options for Page" do
-      assert_equal 25, Page.typus_options_for(:form_rows)
-    end
-
-  end
-
-  context "typus_application" do
-
-    should "return application for Post" do
-      assert_equal "Blog", Post.typus_application
-    end
-
-    should "return application for View" do
-      assert_equal "Unknown", View.typus_application
-    end
-
-  end
-
-  context "typus_field_options_for" do
-
-    should "verify on models" do
-      assert_equal [ :status ], Post.typus_field_options_for(:selectors)
-      assert_equal [ :permalink ], Post.typus_field_options_for(:read_only)
-      assert_equal [ :created_at ], Post.typus_field_options_for(:auto_generated)
-    end
-
-  end
-
-  context "typus_boolean" do
-
-    should "accept strings" do
-      expected = {"Inactive"=>"false", "Active"=>"true"}
-      assert_equal expected, TypusUser.typus_boolean("status")
-    end
-
-    should "accept symbols" do
-      expected = {"Inactive"=>"false", "Active"=>"true"}
-      assert_equal expected, TypusUser.typus_boolean(:status)
-    end
-
-    should "return booleans for TypusUser" do
-      expected = {"Active" => "true", "Inactive" => "false"}
-      assert_equal expected, TypusUser.typus_boolean(:status)
-    end
-
-    should "return booleans for Post" do
-      expected = {"True" => "true", "False" => "false"}
-      assert_equal expected, Post.typus_boolean(:status)
-    end
-
-  end
-
-  context "typus_date_format" do
-
-    should "accept strings" do
-      assert_equal :db, Post.typus_date_format("unknown")
-    end
-
-    should "accept symbols" do
-      assert_equal :db, Post.typus_date_format(:unknown)
-    end
-
-    should "return date_format for Post" do
-      assert_equal :db, Post.typus_date_format
-      assert_equal :post_short, Post.typus_date_format(:created_at)
-    end
-
-  end
-
-  context "typus_template" do
-
-    should "accept strings" do
-      assert_equal "datepicker", Post.typus_template("published_at")
-    end
-
-    should "accept symbols" do
-      assert_equal "datepicker", Post.typus_template(:published_at)
-    end
-
-    should "return nil if template does not exist" do
-      assert_nil Post.typus_template(:created_at)
-    end
-
-  end
-
-  context "typus_defaults_for" do
-
-    should "accept strings" do
-      assert_equal %w( title ), Post.typus_defaults_for("search")
-    end
-
-    should "accepts symbols" do
-      assert_equal %w( title ), Post.typus_defaults_for(:search)
-    end
-
-    should "return default_for relationships on Post" do
-      assert_equal %w( assets categories comments views ), Post.typus_defaults_for(:relationships)
-    end
-
-  end
-
-  context "typus_search_fields" do
-
-    should "return a hash with the search modifiers" do
-      search = ["=id", "^title", "body"]
-      Post.stubs(:typus_defaults_for).with(:search).returns(search)
-      expected = {"body"=>"@", "title"=>"^", "id"=>"="}
-      assert_equal expected, Post.typus_search_fields
-    end
-
-    should "return and empty hash" do
-      search = []
-      Post.stubs(:typus_defaults_for).with(:search).returns(search)
-      expected = {}
-      assert_equal expected, Post.typus_search_fields
-    end
-
-  end
-
-  context "typus_export_formats" do
-
-    should "return post formats" do
-      assert_equal ["csv", "xml"], Post.typus_export_formats
-    end
-
-    should "return picture formats" do
-      assert_equal [], Picture.typus_export_formats
-    end
-
-  end
-
-  context "typus_order_by" do
-
-    should "return defaults_for order_by on Post" do
-      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)
-    end
-
-  end
-
-  context "build_conditions" do
-
-    should "generate conditions for id" do
-      Post.stubs(:typus_defaults_for).with(:search).returns(["id"])
-
-      params = { :search => '1' }
-      expected = "(id LIKE '%1%')"
-
-      assert_equal expected, Post.build_conditions(params).first
-    end
-
-    should "generate conditions for fields starting with equal" do
-      Post.stubs(:typus_defaults_for).with(:search).returns(["=id"])
-
-      params = { :search => '1' }
-      expected = "(id LIKE '1')"
-
-      assert_equal expected, Post.build_conditions(params).first
-    end
-
-    should "generate conditions for fields starting with ^" do
-      Post.stubs(:typus_defaults_for).with(:search).returns(["^id"])
-
-      params = { :search => '1' }
-      expected = "(id LIKE '1%')"
-
-      assert_equal expected, Post.build_conditions(params).first
-    end
-
-    should "return_sql_conditions_on_search_for_typus_user" do
-      expected = case ENV["DB"]
-                 when /postgresql/
-                   "(TEXT(role) LIKE '%francesc%' OR TEXT(last_name) LIKE '%francesc%' OR TEXT(email) LIKE '%francesc%' OR TEXT(first_name) LIKE '%francesc%')"
-                 else
-                   "(role LIKE '%francesc%' OR last_name LIKE '%francesc%' OR email LIKE '%francesc%' OR first_name LIKE '%francesc%')"
-                end
-
-      params = { :search => "francesc" }
-      assert_equal expected, TypusUser.build_conditions(params).first
-      params = { :search => "Francesc" }
-      assert_equal expected, TypusUser.build_conditions(params).first
-    end
-
-    should "return_sql_conditions_on_search_and_filter_for_typus_user" do
-      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 = "((role LIKE '%francesc%' OR last_name LIKE '%francesc%' OR email LIKE '%francesc%' OR first_name 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
-
-    should "return_sql_conditions_on_filtering_typus_users_by_status" do
-      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
-
-    should "return_sql_conditions_on_filtering_typus_users_by_created_at today" do
-      expected = "(created_at BETWEEN '#{Time.zone.now.beginning_of_day.to_s(:db)}' AND '#{Time.zone.now.beginning_of_day.tomorrow.to_s(:db)}')"
-      params = { :created_at => "today" }
-      assert_equal expected, TypusUser.build_conditions(params).first
-    end
-
-    should "return_sql_conditions_on_filtering_typus_users_by_created_at last_few_days" do
-      expected = "(created_at BETWEEN '#{3.days.ago.beginning_of_day.to_s(:db)}' AND '#{Time.zone.now.beginning_of_day.tomorrow.to_s(:db)}')"
-      params = { :created_at => "last_few_days" }
-      assert_equal expected, TypusUser.build_conditions(params).first
-    end
-
-    should "return_sql_conditions_on_filtering_typus_users_by_created_at last_7_days" do
-      expected = "(created_at BETWEEN '#{6.days.ago.beginning_of_day.to_s(:db)}' AND '#{Time.zone.now.beginning_of_day.tomorrow.to_s(:db)}')"
-      params = { :created_at => "last_7_days" }
-      assert_equal expected, TypusUser.build_conditions(params).first
-    end
-
-    should "return_sql_conditions_on_filtering_typus_users_by_created_at last_30_days" do
-      expected = "(created_at BETWEEN '#{Time.zone.now.beginning_of_day.prev_month.to_s(:db)}' AND '#{Time.zone.now.beginning_of_day.tomorrow.to_s(:db)}')"
-      params = { :created_at => "last_30_days" }
-      assert_equal expected, TypusUser.build_conditions(params).first
-    end
-
-    should "return_sql_conditions_on_filtering_posts_by_published_at today" do
-      expected = "(published_at BETWEEN '#{Time.zone.now.beginning_of_day.to_s(:db)}' AND '#{Time.zone.now.beginning_of_day.tomorrow.to_s(:db)}')"
-      params = { :published_at => "today" }
-      assert_equal expected, Post.build_conditions(params).first
-    end
-
-    should "return_sql_conditions_on_filtering_posts_by_string" do
-      expected = case ENV["DB"]
-                 when /mysql/
-                   "(`typus_users`.`role` = 'admin')"
-                 else
-                   "(\"typus_users\".\"role\" = 'admin')"
-                 end
-
-      params = { :role => "admin" }
-      assert_equal expected, TypusUser.build_conditions(params).first
-    end
-
-  end
-
-  context "class_methods" do
-
-    should "verify typus_user_id exists on Post" do
-      assert Post.typus_user_id?
-    end
-
-    should "verify typus_user_id does not exist on Post" do
-      assert !TypusUser.typus_user_id?
-    end
-
-  end
-
-end