typus 0.9.39 → 1.0.0.pre

data/test/schema.rb

@@ -9,6 +9,8 @@ ActiveRecord::Schema.define do
     t.integer :position
   end
 
+  add_index :assets, :resource_id
+
   create_table :categories, :force => true do |t|
     t.string :name
     t.string :permalink
@@ -20,6 +22,7 @@ ActiveRecord::Schema.define do
     t.string :email, :name
     t.text :body
     t.integer :post_id
+    t.boolean :spam, :default => false
   end
 
   add_index :comments, :post_id
@@ -31,20 +34,38 @@ ActiveRecord::Schema.define do
   create_table :pages, :force => true do |t|
     t.string :title
     t.text :body
-    t.boolean :is_published
+    t.string :status
     t.integer :parent_id
   end
 
+  add_index :pages, :parent_id
+
   create_table :posts, :force => true do |t|
     t.string :title
     t.text :body
-    t.boolean :status
+    t.string :status
     t.integer :favorite_comment_id
     t.timestamps
     t.datetime :published_at
     t.integer :typus_user_id
   end
 
+  add_index :posts, :favorite_comment_id
+  add_index :posts, :typus_user_id
+
+  create_table :pictures, :force => true do |t|
+    t.string :title
+    t.string :picture_file_name
+    t.string :picture_content_type
+    t.integer :picture_file_size
+    t.datetime :picture_updated_at
+    t.datetime :created_at
+    t.datetime :updated_at
+    t.integer :typus_user_id
+  end
+
+  add_index :pictures, :typus_user_id
+
   create_table :typus_users, :force => true do |t|
     t.string :first_name, :default => "", :null => false
     t.string :last_name, :default => "", :null => false
@@ -58,12 +79,16 @@ ActiveRecord::Schema.define do
     t.timestamps
   end
 
+  add_index :typus_users, :token
+
   create_table :views, :force => true do |t|
     t.string :ip, :default => '127.0.0.1'
     t.integer :post_id
     t.timestamps
   end
 
+  add_index :views, :post_id
+
   create_table :categories_posts, :force => true, :id => false do |t|
     t.column :category_id, :integer
     t.column :post_id, :integer
@@ -72,4 +97,4 @@ ActiveRecord::Schema.define do
   add_index :categories_posts, :category_id
   add_index :categories_posts, :post_id
 
-end
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+
+ENV["RAILS_ENV"] = "test"
+
+# Boot rails application and testing parts ...
+require "fixtures/rails_app/config/environment"
+require "rails/test_help"
+
+# As we are simulating the application we need to reload the
+# configurations to get the custom paths.
+Typus.reload!
+
+# Different DB settings and load our schema.
+connection = case ENV["DB"]
+             when "mysql"
+               { :adapter => "mysql", :database => "typus_test" }
+             when "pg"
+               { :adapter => "postgresql", :database => "typus_test", :encoding => "unicode" }
+             else
+               { :adapter => "sqlite3", :database => ":memory:" }
+             end
+
+ActiveRecord::Base.establish_connection(connection)
+load File.join(File.dirname(__FILE__), "schema.rb")
+Dir[File.join(File.dirname(__FILE__), "factories", "**","*.rb")].each { |factory| require factory }
+
+class ActiveSupport::TestCase
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+end

data/test/unit/admin/mailer_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+class Admin::MailerTest < ActiveSupport::TestCase
+
+  setup do
+    @typus_user = Factory(:typus_user)
+    @url = "http://test.host/admin/account/#{@typus_user.token}"
+    @email = Admin::Mailer.reset_password_link(@typus_user, @url)
+  end
+
+  should "verify email from is nil by default" do
+    assert Admin::Mailer.default[:from].nil?
+  end
+
+  should "verify email to is typus user email" do
+    assert @email.to.include?(@typus_user.email)
+  end
+
+  should "verify email subject" do
+    expected = "[#{Typus.admin_title}] Reset password"
+    assert_equal expected, @email.subject
+  end
+
+  should "verify default email mime type" do
+    assert_equal "text/plain", @email.mime_type
+  end
+
+  should "verify email contains reset password link with token" do
+    assert_match @url, @email.body.encoded
+  end
+
+end

data/test/unit/typus_user_roles_test.rb

@@ -1,97 +1,105 @@
-require 'test/helper'
+require "test_helper"
 
 class TypusUserRolesTest < ActiveSupport::TestCase
 
-  def test_should_get_list_of_roles
+  should "get a list of roles" do
     roles = %w( admin designer editor )
     assert_equal roles, Typus::Configuration.roles.map(&:first).sort
   end
 
-  def test_admin_role_settings
+  context "A TypusUser with role admin" do
 
-    typus_user = typus_users(:admin)
-    assert_equal 'admin', typus_user.role
+    setup do
+      @typus_user = Factory(:typus_user)
+      @models = %w( Asset Category Comment Git Page Post Status TypusUser View WatchDog )
+    end
 
-    models = %w( Asset Category Comment Delayed::Task Git Page Post Status TypusUser View WatchDog )
-    assert_equal models, typus_user.resources.map(&:first).sort
+    should "verify models access" do
+      assert_equal @models, @typus_user.resources.map(&:first).sort
+    end
 
-    # Order exists on the roles, but, as we compact the hash, the
-    # resource is removed.
-    assert !typus_user.resources.map(&:first).include?('Order')
+    should "verify resources without actions related are removed" do
+      assert !@typus_user.resources.map(&:first).include?('Order')
+    end
 
-    resources = %w( Git Status WatchDog )
-    models.delete_if { |m| resources.include?(m) }
+    should "have access to all actions on models" do
+      models = %w( Asset Category Comment Page Post TypusUser View )
+      %w( create read update destroy ).each { |a| models.each { |m| assert @typus_user.can?(a, m) } }
+    end
 
-    %w( create read update destroy ).each do |action|
-      models.each { |model| assert typus_user.can_perform?(model, action), "Error on #{model} #{action}" }
+    should "verify we can perform action on resource" do
+      assert @typus_user.can?('index', 'Status', { :special => true })
     end
 
-    # Order resource doesn't have an index action, so we current user 
-    # cannot perform the action.
-    assert !typus_user.can_perform?('Order', 'index')
+    should "verify we cannot perform action on resource" do
+      assert @typus_user.cannot?('show', 'Status', { :special => true })
+    end
 
-    # Status resource has an index action, but not a show one.
-    # We add the { :special => true } option to by-pass the action 
-    # renaming performed in the TypusUser#can_perform? method.
-    assert typus_user.can_perform?('Status', 'index', { :special => true })
-    assert !typus_user.can_perform?('Status', 'show', { :special => true })
+    should "verify we cannot perform actions on resources which don't have that action defined" do
+      assert @typus_user.cannot?('index', 'Order')
+    end
 
   end
 
-  def test_editor_role_settings
+  context "A TypusUser with role editor" do
 
-    typus_user = typus_users(:editor)
-    assert_equal 'editor', typus_user.role
+    setup do
+      @typus_user = Factory(:typus_user, :role => "editor")
+    end
 
-    %w( Category Comment Git Post TypusUser ).each do |model|
-      assert typus_user.resources.map(&:first).include?(model)
+    should "verify models access" do
+      models = %w( Category Comment Git Post TypusUser View )
+      assert_equal models, @typus_user.resources.map(&:first).sort
     end
 
-    # Category: create, read, update
-    %w( create read update ).each { |action| assert typus_user.can_perform?('Category', action) }
-    %w( delete ).each { |action| assert !typus_user.can_perform?('Category', action) }
+    should "only create, read and update categories" do
+      %w( create read update ).each { |a| assert @typus_user.can?(a, 'Category') }
+      %w( delete ).each { |a| assert @typus_user.cannot?(a, 'Category') }
+    end
 
-    # Post: create, read, update
-    %w( create read update ).each { |action| assert typus_user.can_perform?('Post', action) }
-    %w( delete ).each { |action| assert !typus_user.can_perform?('Post', action) }
+    should "only create, read and update posts" do
+      %w( create read update ).each { |a| assert @typus_user.can?(a, 'Post') }
+      %w( delete ).each { |a| assert @typus_user.cannot?(a, 'Post') }
+    end
 
-    # Comment: read, update, delete
-    %w( read update delete ).each { |action| assert typus_user.can_perform?('Comment', action) }
-    %w( create ).each { |action| assert !typus_user.can_perform?('Comment', action) }
+    should "only read, update and delete comments" do
+      %w( read update delete ).each { |a| assert @typus_user.can?(a, 'Comment') }
+      %w( create ).each { |a| assert @typus_user.cannot?(a, 'Comment') }
+    end
 
-    # TypusUser: read, update
-    %w( read update ).each { |action| assert typus_user.can_perform?('TypusUser', action) }
-    %w( create delete ).each { |action| assert !typus_user.can_perform?('TypusUser', action) }
+    should "only read and update typus_users" do
+      %w( read update ).each { |a| assert @typus_user.can?(a, 'TypusUser') }
+      %w( create delete ).each { |a| assert @typus_user.cannot?(a, 'TypusUser') }
+    end
 
   end
 
-  def test_designer_role_settings
-
-    typus_user = typus_users(:designer)
-    assert_equal 'designer', typus_user.role
+  context "A TypusUser with role designer" do
 
-    models = %w( Category Comment Post )
-    assert_equal models, typus_user.resources.map(&:first).sort
+    setup do
+      @typus_user = Factory(:typus_user, :role => "designer")
+    end
 
-    # Category: read, update
-    %w( read update ).each { |action| assert typus_user.can_perform?('Category', action) }
-    %w( create delete ).each { |action| assert !typus_user.can_perform?('Category', action) }
+    should "verify models access" do
+      models = %w( Category Comment Post )
+      assert_equal models, @typus_user.resources.map(&:first).sort
+    end
 
-    # Comment: read
-    %w( read ).each { |action| assert typus_user.can_perform?('Comment', action) }
-    %w( create update delete ).each { |action| assert !typus_user.can_perform?('Comment', action) }
+    should "only read and update categories" do
+      %w( read update ).each { |a| assert @typus_user.can?(a, 'Category') }
+      %w( create delete ).each { |a| assert @typus_user.cannot?(a, 'Category') }
+    end
 
-    # Post: read, update
-    %w( read update ).each { |action| assert typus_user.can_perform?('Post', action) }
-    %w( create delete ).each { |action| assert !typus_user.can_perform?('Post', action) }
+    should "only read comments" do
+      %w( read ).each { |a| assert @typus_user.can?(a, 'Comment') }
+      %w( create update delete ).each { |a| assert @typus_user.cannot?(a, 'Comment') }
+    end
 
-  end
+    should "only read and update posts" do
+      %w( read update ).each { |a| assert @typus_user.can?(a, 'Post') }
+      %w( create delete ).each { |a| assert @typus_user.cannot?(a, 'Post') }
+    end
 
-  def test_admin_can_perform_any_action_on_delayed_task_model
-    typus_user = typus_users(:admin)
-    action = 'whatever_i_want_to'
-    klass = Delayed::Task
-    assert typus_user.can_perform?(klass, action), "Admin can't perform `#{action}` on `#{klass}`."
   end
 
-end
+end

data/test/unit/typus_user_test.rb

@@ -1,178 +1,91 @@
-require 'test/helper'
+require "test_helper"
 
 class TypusUserTest < ActiveSupport::TestCase
 
-  def setup
-    @data = { :first_name => '', 
-              :last_name => '', 
-              :email => 'test@example.com', 
-              :password => '12345678', 
-              :password_confirmation => '12345678', 
-              :role => Typus::Configuration.options[:root], 
-              :preferences => { :locale => :en } }
-    @typus_user = TypusUser.new(@data)
+  [ %Q(this_is_chelm@example.com\n<script>location.href="http://spammersite.com"</script>),
+    'admin', 'TEST@EXAMPLE.COM', 'test@example', 'test@example.c', 'testexample.com' ].each do |value|
+    should_not allow_value(value).for(:email)
   end
 
-  def test_should_verify_typus_user_attributes
-    [ :first_name, :last_name, :email, :role, :salt, :crypted_password ].each do |attribute|
-      assert TypusUser.instance_methods.map { |i| i.to_sym }.include?(attribute)
-    end
+  [ 'test+filter@example.com', 'test.filter@example.com', 'test@example.co.uk', 'test@example.es' ].each do |value|
+    should allow_value(value).for(:email)
   end
 
-  def test_should_verify_definition_on_instance_methods
-    [ :is_root?, :authenticated? ].each do |instance_method|
-      assert TypusUser.instance_methods.map { |i| i.to_sym }.include?(instance_method)
-    end
-  end
+  should validate_presence_of :role
 
-  def test_should_verify_email_format
-    @typus_user.email = 'admin'
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:email)
-  end
+  should_not allow_mass_assignment_of :status
 
-  def test_should_verify_email_is_not_valid
-    email = <<-RAW
-this_is_chelm@example.com
-<script>location.href="http://spammersite.com"</script>
-    RAW
-    @typus_user.email = email
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:email)
-  end
+  should ensure_length_of(:password).is_at_least(8).is_at_most(40)
 
-  def test_should_verify_emails_are_downcase
-    email = 'TEST@EXAMPLE.COM'
-    @typus_user.email = email
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:email)
-  end
+  # should validate_uniqueness_of :email
+
+  context "TypusUser" do
 
-  def test_should_verify_some_valid_emails_schemas
-    emails = [ 'test+filter@example.com', 
-               'test.filter@example.com', 
-               'test@example.co.uk', 
-               'test@example.es' ]
-    emails.each do |email|
-      @typus_user.email = email
-      assert @typus_user.valid?
+    setup do
+      @typus_user = Factory(:typus_user)
     end
-  end
 
-  def test_should_verify_invalid_emails_are_detected
-    emails = [ 'test@example', 'test@example.c', 'testexample.com' ]
-    emails.each do |email|
-      @typus_user.email = email
-      assert @typus_user.invalid?
-      assert @typus_user.errors.invalid?(:email)
+    should "verify definition" do
+      attributes = %w( id first_name last_name email role status salt crypted_password token preferences created_at updated_at )
+      TypusUser.columns.collect { |u| u.name }.each { |c| assert attributes.include?(c) }
     end
-  end
 
-  def test_should_verify_email_is_unique
-    @typus_user.save
-    @another_typus_user = TypusUser.new(@data)
-    assert @another_typus_user.invalid?
-    assert @another_typus_user.errors.invalid?(:email)
-  end
+    should "return email when first_name and last_name are not set" do
+      assert_equal @typus_user.email, @typus_user.name
+    end
 
-  def test_should_verify_length_of_password_when_under_within
-    @typus_user.password = '1234'
-    @typus_user.password_confirmation = '1234'
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:password)
-  end
+    should "return name when first_name and last_name are set" do
+      @typus_user.first_name, @typus_user.last_name = "John", "Lock"
+      assert_equal "John Lock", @typus_user.name
+    end
 
-  def test_should_verify_length_of_password_when_its_within_on_lower_limit
-    @typus_user.password = '=' * 8
-    @typus_user.password_confirmation = '=' * 8
-    assert @typus_user.valid?
-  end
+    should "verify salt never changes" do
+      salt, crypted_password = @typus_user.salt, @typus_user.crypted_password
 
-  def test_should_verify_length_of_password_when_its_within_on_upper_limit
-    @typus_user.password = '=' * 40
-    @typus_user.password_confirmation = '=' * 40
-    assert @typus_user.valid?
-  end
+      @typus_user.update_attributes :password => '11111111', :password_confirmation => '11111111'
+      assert_equal salt, @typus_user.salt
+      assert_not_equal crypted_password, @typus_user.crypted_password
+    end
 
-  def test_should_verify_length_of_password_when_its_over_within
-    @typus_user.password = '=' * 50
-    @typus_user.password_confirmation = '=' * 50
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:password)
-  end
+    should "verify authenticated?" do
+      assert @typus_user.authenticated?('12345678')
+      assert !@typus_user.authenticated?('87654321')
+    end
 
-  def test_should_verify_confirmation_of_password
+    should "verify can? (with a model as a param)" do
+      assert @typus_user.can?('delete', TypusUser)
+    end
 
-    @typus_user.password = '12345678'
-    @typus_user.password_confirmation = '87654321'
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:password)
+    should "verify can? (with a string as a param)" do
+      assert @typus_user.can?('delete', 'TypusUser')
+    end
 
-    @typus_user.password = '12345678'
-    @typus_user.password_confirmation = ''
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:password)
+    should "verify cannot?" do
+      assert !@typus_user.cannot?('delete', 'TypusUser')
+    end
 
   end
 
-  def test_should_verify_role
-    @typus_user.role = ''
-    assert @typus_user.invalid?
-    assert @typus_user.errors.invalid?(:role)
-    assert_equal "can't be blank", @typus_user.errors[:role]
-  end
+  context "TypusUser which is not root" do
 
-  def test_should_return_name_when_only_email
-    assert_equal @typus_user.email, @typus_user.name
-  end
+    setup do
+      @typus_user = Factory(:typus_user, :role => "editor")
+    end
 
-  def test_should_return_name_when_theres_first_name_and_last_name
-    @typus_user.first_name = 'John'
-    @typus_user.last_name = 'Smith'
-    assert_equal 'John Smith', @typus_user.name
-  end
+    should "verify is not root" do
+      assert @typus_user.is_not_root?
+      assert !@typus_user.is_root?
+    end
 
-  def test_should_return_verify_is_root
-    assert @typus_user.is_root?
-    editor = typus_users(:editor)
-    assert !editor.is_root?
   end
 
-  def test_should_verify_authenticated
-    @typus_user.save
-    assert @typus_user.authenticated?('12345678')
-    assert !@typus_user.authenticated?('87654321')
-  end
+  context "Class methods" do
 
-  def test_should_verify_typus_user_can_be_created
-    assert_difference 'TypusUser.count' do
-      TypusUser.create(@data)
+    should "verify generate requires the role" do
+      assert TypusUser.generate(:email => 'demo@example.com', :password => 'XXXXXXXX').valid?
+      assert TypusUser.generate(:email => 'demo@example.com', :password => 'XXXXXXXX', :role => 'admin').valid?
     end
-  end
-
-  def test_should_verify_salt_on_user_never_changes
-
-    @typus_user.save
-    salt = @typus_user.salt
-    crypted_password = @typus_user.crypted_password
-
-    @typus_user.update_attributes :password => '11111111', :password_confirmation => '11111111'
-    assert_equal salt, @typus_user.salt
-    assert_not_equal crypted_password, @typus_user.crypted_password
-
-  end
-
-  def test_should_verify_generate
-    assert TypusUser.respond_to?(:generate)
-    assert TypusUser.generate(:email => 'demo@example.com', :password => 'XXXXXXXX').invalid?
-    assert TypusUser.generate(:email => 'demo@example.com', :password => 'XXXXXXXX', :role => 'admin').valid?
-  end
 
-  def test_should_verify_can_perform?
-    assert TypusUser.instance_methods.map {|i| i.to_sym }.include?(:can_perform?)
-    @current_user = TypusUser.find(:first)
-    assert @current_user.can_perform?(TypusUser, 'delete')
-    assert @current_user.can_perform?('TypusUser', 'delete')
   end
 
-end
+end