typus 1.0.0.pre8 → 1.0.0.pre9

data/test/integration/login_test.rb

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

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

@@ -2,34 +2,85 @@ require "test_helper"
 
 class ActiveRecordTest < ActiveSupport::TestCase
 
-  should "verify mapping instace method with an array" do
-    post = Factory(:post)
-    assert_equal "published", post.mapping(:status)
-  end
+  context "mapping" do
 
-  should "verify mapping instace method with an array when status if unpublished" do
-    post = Factory(:post, :status => "unpublished")
-    assert_equal "unpublished", post.mapping(:status)
-  end
+    context "with an array" do
 
-  should "verify mapping instace method with a hash" do
-    page = Factory(:page)
-    assert_equal "Published", page.mapping(:status)
-    page = Factory(:page, :status => "unpublished")
-    assert_equal "Not Published", page.mapping(:status)
-  end
+      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
 
-  should "verify to_label instace method" do
-    assert_equal "admin@example.com", Factory(:typus_user).to_label
   end
 
-  should "verify to_label instace method for post" do
-    assert_match /Post#/, Factory(:post).to_label
+  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
 
-  should "verify to_resource instance method" do
-    assert_equal "typus_users", TypusUser.to_resource
-    assert_equal "delayed/tasks", Delayed::Task.to_resource
+  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

@@ -2,14 +2,10 @@ require "test_helper"
 
 class ArrayTest < ActiveSupport::TestCase
 
-  should "verify Array#to_hash_with" do
+  should "verify to_hash_with" do
     keys, values = %w(a b c), %w(1 2 3)
     expected = { "a" => "1", "b" => "2", "c" => "3" }
-
-    hash = keys.to_hash_with(values)
-
-    assert hash.kind_of?(Hash)
-    assert_equal expected, hash
+    assert_equal expected, keys.to_hash_with(values)
   end
 
 end

data/test/lib/support/string_test.rb

@@ -7,42 +7,33 @@ class StringTest < ActiveSupport::TestCase
     assert_equal %w( a b c ), " a  , b,  c ".extract_settings
   end
 
-  should "remove prefix" 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
+  context "remove_prefix" do
 
-  should "remove prefix with params" 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
+    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 "extract_resource" do
-    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
+    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
 
-  should "extract_class" do
-    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
 
-  should "extract_human_name" do
-    assert_equal "Post", "admin/posts".extract_human_name
-    assert_equal "Typus user", "admin/typus_users".extract_human_name
-    assert_equal "Task", "admin/delayed/tasks".extract_human_name
-  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
 
-  should "verify String#typus_actions_on" do
-    assert_equal %w(cleanup), "Post".typus_actions_on("index")
-    assert_equal %w(cleanup), "Post".typus_actions_on(:index)
-    assert_equal %w(send_as_newsletter preview), "Post".typus_actions_on(:edit)
-    assert "TypusUser".typus_actions_on(:unexisting).empty?
-    assert "Post".typus_actions_on(:index).kind_of?(Array)
   end
 
 end

data/test/lib/typus/active_record_test.rb

@@ -2,70 +2,82 @@ require "test_helper"
 
 class ActiveRecordTest < ActiveSupport::TestCase
 
-  should "verify model fields is an instance of active support ordered hash" do
-    assert TypusUser.model_fields.instance_of?(ActiveSupport::OrderedHash)
-  end
+  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
 
-  should "return model fields for TypusUser" 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 "return model fields for post" 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
+  context "model_relationships" do
 
-  should "verify_model_relationships_is_an_instance_of_active_support_ordered_hash" do
-    assert TypusUser.model_relationships.instance_of?(ActiveSupport::OrderedHash)
-  end
+    should "be an ActiveSupport::OrderedHash" do
+      assert TypusUser.model_relationships.instance_of?(ActiveSupport::OrderedHash)
+    end
 
-  should "return_model_relationships_for_post" 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]
+    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
 
-  should "return_description_of_a_model" do
-    assert_equal "System Users Administration", TypusUser.typus_description
+  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
+  context "typus_fields_for" do
 
-    should "verify typus_fields_for accepts strings" do
+    should "accept strings" do
       assert_equal %w( email role status ), TypusUser.typus_fields_for("list").keys
     end
 
-    should "verify typus_fields_for accepts symbols" do
+    should "accept symbols" do
       assert_equal %w( email role status ), TypusUser.typus_fields_for(:list).keys
     end
 
-    should "return_typus_fields_for_list_for_typus_user" do
+    should "return list fields for TypusUser" do
       expected_fields = [["email", :string],
                          ["role", :selector],
                          ["status", :boolean]]
@@ -73,7 +85,7 @@ class ActiveRecordTest < ActiveSupport::TestCase
       assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for(:list).values
     end
 
-    should "return_typus_fields_for_form_for_typus_user" do
+    should "return form fields for TypusUser" do
       expected_fields = [["first_name", :string],
                          ["last_name", :string],
                          ["role", :selector],
@@ -85,30 +97,30 @@ class ActiveRecordTest < ActiveSupport::TestCase
       assert_equal expected_fields.map { |i| i.last }, TypusUser.typus_fields_for(:form).values
     end
 
-    should "return_typus_fields_for_form_for_picture" do
+    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_typus_fields_for_a_model_without_configuration" do
+    should "return form fields for a Model without configuration" do
       assert Class.new(ActiveRecord::Base).typus_fields_for(:form).empty?
     end
 
-    should "return_typus_fields_for_relationship_for_typus_user" do
+    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_all_fields_for_undefined_field_type_on_typus_user" do
+    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
+  context "typus_filters" do
 
-    should "return_filters_for_typus_user" 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"]
@@ -116,7 +128,7 @@ class ActiveRecordTest < ActiveSupport::TestCase
       assert_equal expected.map { |i| i.last }, TypusUser.typus_filters.values
     end
 
-    should "return_post_typus_filters" do
+    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
@@ -125,52 +137,63 @@ class ActiveRecordTest < ActiveSupport::TestCase
 
   end
 
-  context "Typus actions on" do
+  context "typus_actions_on" do
 
-    should "verify typus_actions_on accepts strings" do
+    should "accept strings" do
       assert_equal %w( cleanup ), Post.typus_actions_on("index")
     end
 
-    should "verify typus_actions_on accepts symbols" do
+    should "accept symbols" do
       assert_equal %w( cleanup ), Post.typus_actions_on(:index)
     end
 
-    should "return_actions_on_list_for_typus_user" do
+    should "return actions on list for TypusUser" do
       assert TypusUser.typus_actions_on(:list).empty?
     end
 
-    should "return Post actions on edit" do
+    should "return actions on edit for Post" do
       assert_equal %w( send_as_newsletter preview ), Post.typus_actions_on(:edit)
     end
 
-    should "return Post actions" do
-      assert_equal %w( cleanup preview send_as_newsletter ), Post.typus_actions.sort
-    end
-
   end
 
-  context "Typus options for" do
+  context "typus_options_for" do
 
-    should "verify typus_options_for accepts strings" do
+    should "accept strings" do
       assert_equal 15, Post.typus_options_for("form_rows")
     end
 
-    should "verify typus_options_for accepts symbols" do
+    should "accept symbols" do
       assert_equal 15, Post.typus_options_for(:form_rows)
     end
 
-    should "verify typus_options_for returns nil when options doesnt exist" do
-      assert TypusUser.typus_options_for(:unexisting).nil?
+    should "return nil when options do not exist" do
+      assert_nil TypusUser.typus_options_for(:unexisting)
     end
 
-    should "return options for post and page" do
+    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 field options for" do
+  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)
@@ -180,71 +203,110 @@ class ActiveRecordTest < ActiveSupport::TestCase
 
   end
 
-  context "Typus boolean" do
+  context "typus_boolean" do
 
-    should "verify_typus_boolean_is_an_instance_of_active_support_ordered_hash" do
-      assert TypusUser.typus_boolean("status").instance_of?(ActiveSupport::OrderedHash)
+    should "accept strings" do
+      expected = {"Inactive"=>"false", "Active"=>"true"}
+      assert_equal expected, TypusUser.typus_boolean("status")
     end
 
-    should "verify typus_boolean accepts strings" do
-      assert_equal [ :true, :false ], TypusUser.typus_boolean("status").keys
+    should "accept symbols" do
+      expected = {"Inactive"=>"false", "Active"=>"true"}
+      assert_equal expected, TypusUser.typus_boolean(:status)
     end
 
-    should "verify typus_boolean accepts symbols" do
-      assert_equal [ :true, :false ], TypusUser.typus_boolean(:status).keys
+    should "return booleans for TypusUser" do
+      expected = {"Active" => "true", "Inactive" => "false"}
+      assert_equal expected, TypusUser.typus_boolean(:status)
     end
 
-    should "return_booleans_for_typus_users" do
-      assert_equal [ :true, :false ], TypusUser.typus_boolean(:status).keys
-      assert_equal [ "Active", "Inactive" ], TypusUser.typus_boolean(:status).values
-    end
-
-    should "return_booleans_for_post" do
-      assert_equal [ :true, :false ], Post.typus_boolean(:status).keys
-      assert_equal [ "True", "False" ], Post.typus_boolean(:status).values
+    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
+  context "typus_date_format" do
 
-    should "verify typus_date_format accepts strings" do
+    should "accept strings" do
       assert_equal :db, Post.typus_date_format("unknown")
     end
 
-    should "verify typus_date_format accepts symbols" do
+    should "accept symbols" do
       assert_equal :db, Post.typus_date_format(:unknown)
     end
 
-    should "return typus_date_formats for Post" do
+    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 defaults for" do
+  context "typus_template" do
 
-    should "verify typus_defaults_for on Model accepts strings" do
-      assert_equal %w( title ), Post.typus_defaults_for("search")
+    should "accept strings" do
+      assert_equal "datepicker", Post.typus_template("published_at")
     end
 
-    should "verify typus_defaults_for on Model accepts symbols" do
-      assert_equal %w( title ), Post.typus_defaults_for(:search)
+    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 "return defaults_for search on Post" do
+    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)
-      assert !Post.typus_defaults_for(:relationships).empty?
     end
 
   end
 
-  context "Typus order by" do
+  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
@@ -253,7 +315,7 @@ class ActiveRecordTest < ActiveSupport::TestCase
 
   end
 
-  context "Build conditions" do
+  context "build_conditions" do
 
     should "generate conditions for id" do
       Post.stubs(:typus_defaults_for).with(:search).returns(["id"])
@@ -374,7 +436,7 @@ class ActiveRecordTest < ActiveSupport::TestCase
 
   end
 
-  context "Class methods" do
+  context "class_methods" do
 
     should "verify typus_user_id exists on Post" do
       assert Post.typus_user_id?