fesplugas-typus 0.9.0

data/test/lib/typus_test.rb

@@ -0,0 +1,105 @@
+require 'test/helper'
+
+class TypusTest < ActiveSupport::TestCase
+
+  def test_should_return_locales
+    initializer = "#{Rails.root}/config/initializers/typus.rb"
+    return if File.exists?(initializer)
+    assert Typus.respond_to?(:locales)
+    assert Typus.locales.kind_of?(Array)
+    assert_equal [["English", :en]], Typus.locales
+  end
+
+  def test_should_return_default_locale
+    assert Typus.respond_to?(:default_locale)
+    assert Typus.default_locale.kind_of?(Symbol)
+    assert_equal :en, Typus.default_locale
+  end
+
+  def test_should_return_applications_and_should_be_sorted
+    assert Typus.respond_to?(:applications)
+    assert Typus.applications.kind_of?(Array)
+    assert_equal %w( Blog Site Typus ), Typus.applications
+  end
+
+  def test_should_return_modules_of_an_application
+    assert Typus.respond_to?(:application)
+    assert_equal %w( Comment Post ), Typus.application('Blog')
+  end
+
+  def test_should_return_modules_of_a_module
+    assert Typus.respond_to?(:module)
+    assert_equal %w( Category ), Typus.module(Post)
+  end
+
+  def test_should_verify_parent_exists
+    assert Typus.respond_to?(:parent)
+  end
+
+=begin
+
+  # FIXME
+
+  def test_should_verify_parent_for_module
+    assert Typus.parent(TypusUser.name, 'module').kind_of?(String)
+    assert_equal 'Typus', Typus.parent(TypusUser.name, 'module')
+  end
+
+=end
+
+  def test_should_verify_parent_for_application
+    assert Typus.parent(TypusUser, 'application').kind_of?(String)
+    assert_equal 'Typus', Typus.parent(TypusUser, 'application')
+  end
+
+  def test_should_verify_parent_for_nothing
+    assert Typus.parent(TypusUser, 'nothing').kind_of?(String)
+    assert_equal '', Typus.parent(TypusUser, 'nothing')
+  end
+
+  def test_should_return_models_and_should_be_sorted
+    assert Typus.respond_to?(:models)
+    assert Typus.models.kind_of?(Array)
+    assert_equal %w( Asset Category Comment CustomUser Page Post TypusUser ), Typus.models
+  end
+
+  def test_should_verify_resources_class_method
+    assert Typus.respond_to?(:resources)
+    models = Typus.models
+    assert_equal %w( Git Order Status WatchDog ), Typus.resources(models)
+  end
+
+  def test_should_return_description_of_module
+    assert Typus.respond_to?(:module_description)
+    assert_equal 'System Users Administration', Typus.module_description('TypusUser')
+  end
+
+  def test_should_verify_enable_exists
+    assert Typus.respond_to?(:enable)
+  end
+
+  def test_should_verify_enable_exists
+    assert Typus.respond_to?(:generator)
+  end
+
+  def test_should_return_user_class
+    assert_equal TypusUser, Typus.user_class
+  end
+
+  def test_should_return_overwritted_user_class
+    options = { :user_class_name => 'CustomUser' }
+    Typus::Configuration.stubs(:options).returns(options)
+    assert_equal CustomUser, Typus.user_class
+  end
+
+  def test_should_return_user_fk
+    assert_equal 'typus_user_id', Typus.user_fk
+  end
+
+  def test_should_return_overwritted_user_fk
+    options = { :user_fk => 'my_user_fk' }
+    Typus::Configuration.stubs(:options).returns(options)
+    assert_equal 'my_user_fk', Typus.user_fk
+  end
+
+end

data/test/models.rb

@@ -0,0 +1,51 @@
+class Asset < ActiveRecord::Base
+
+  belongs_to :resource, :polymorphic => true
+
+end
+
+class Category < ActiveRecord::Base
+
+  acts_as_list if defined?(ActiveRecord::Acts::List)
+
+  validates_presence_of :name
+  has_and_belongs_to_many :posts
+
+  def self.typus
+  end
+
+end
+
+class Comment < ActiveRecord::Base
+
+  validates_presence_of :name, :email, :body
+  belongs_to :post
+
+end
+
+class CustomUser < ActiveRecord::Base
+end
+
+class Page < ActiveRecord::Base
+
+  acts_as_tree if defined?(ActiveRecord::Acts::Tree)
+
+end
+
+class Post < ActiveRecord::Base
+
+  validates_presence_of :title, :body
+  has_and_belongs_to_many :categories
+  has_many :comments
+  has_many :assets, :as => :resource, :dependent => :destroy
+  belongs_to :favorite_comment, :class_name => 'Comment'
+
+  def self.status
+    %w( true false pending published unpublished )
+  end
+
+  def self.typus
+    'plugin'
+  end
+
+end

data/test/schema.rb

@@ -0,0 +1,64 @@
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+
+  create_table :assets, :force => true do |t|
+    t.string :caption
+    t.string :resource_type
+    t.integer :resource_id
+    t.integer :position
+  end
+
+  create_table :categories, :force => true do |t|
+    t.string :name
+    t.string :permalink
+    t.text :description
+    t.integer :position
+  end
+
+  create_table :comments, :force => true do |t|
+    t.string :email, :name
+    t.text :body
+    t.integer :post_id
+  end
+
+  add_index :comments, :post_id
+
+  create_table :pages, :force => true do |t|
+    t.string :title
+    t.text :body
+    t.boolean :is_published
+    t.integer :parent_id
+  end
+
+  create_table :posts, :force => true do |t|
+    t.string :title
+    t.text :body
+    t.boolean :status
+    t.integer :favorite_comment_id
+    t.timestamps
+    t.datetime :published_at
+    t.integer :typus_user_id
+  end
+
+  create_table :typus_users, :force => true do |t|
+    t.string :first_name, :default => "", :null => false
+    t.string :last_name, :default => "", :null => false
+    t.string :role, :null => false
+    t.string :email, :null => false
+    t.boolean :status, :default => false
+    t.string :token, :null => false
+    t.string :salt, :null => false
+    t.string :crypted_password, :null => false
+    t.timestamps
+  end
+
+  create_table :categories_posts, :force => true, :id => false do |t|
+    t.column :category_id, :integer
+    t.column :post_id, :integer
+  end
+
+  add_index :categories_posts, :category_id
+  add_index :categories_posts, :post_id
+
+end

data/test/unit/typus_mailer_test.rb

@@ -0,0 +1,33 @@
+require 'test/helper'
+
+class TypusMailerTest < ActiveSupport::TestCase
+
+  def setup
+    @user = typus_users(:admin)
+    ActionMailer::Base.default_url_options[:host] = 'test.host'
+    @response = TypusMailer.deliver_reset_password_link(@user)
+  end
+
+  def test_should_verify_email_from_is_defined_by_typus_options
+    assert_equal [ Typus::Configuration.options[:email] ], @response.from
+  end
+
+  def test_should_verify_email_to_is_typus_user_email
+    assert_equal [ @user.email ], @response.to
+  end
+
+  def test_should_verify_email_subject
+    expected = "[#{Typus::Configuration.options[:app_name]}] Reset password"
+    assert_equal expected, @response.subject
+  end
+
+  def test_should_verify_email_contains_reset_password_link_with_token
+    expected = "http://test.host/admin/reset_password?token=1A2B3C4D5E6F"
+    assert_match expected, @response.body
+  end
+
+  def test_should_check_email_contains_signature
+    assert_match /--\n#{Typus::Configuration.options[:app_name]}/, @response.body
+ end
+
+end

data/test/unit/typus_test.rb

@@ -0,0 +1,17 @@
+require 'test/helper'
+
+class TypusTest < ActiveSupport::TestCase
+
+  def test_should_verify_models
+    models = [ Category, Comment, Post, TypusUser ]
+    models.each { |m| assert m.superclass.equal?(ActiveRecord::Base) }
+  end
+
+  def test_should_verify_fixtures_are_loaded
+    assert_equal 3, Category.count
+    assert_equal 4, Comment.count
+    assert_equal 4, Post.count
+    assert_equal 5, TypusUser.count
+  end
+
+end

data/test/unit/typus_user_roles_test.rb

@@ -0,0 +1,90 @@
+require 'test/helper'
+
+class TypusUserRolesTest < ActiveSupport::TestCase
+
+  def test_should_get_list_of_roles
+    roles = %w( admin designer editor )
+    assert_equal roles, Typus::Configuration.roles.map(&:first).sort
+  end
+
+  def test_admin_role_settings
+
+    typus_user = typus_users(:admin)
+    assert_equal 'admin', typus_user.role
+
+    models = %w( Asset Category Comment Git Page Post Status TypusUser WatchDog )
+    assert_equal models, typus_user.resources.map(&:first).sort
+
+    # Order exists on the roles, but, as we compact the hash, the
+    # resource is removed.
+    assert !typus_user.resources.map(&:first).include?('Order')
+
+    resources = %w( Git Status WatchDog )
+    models.delete_if { |m| resources.include?(m) }
+
+    %w( create read update destroy ).each do |action|
+      models.each { |model| assert typus_user.can_perform?(model, action) }
+    end
+
+    # Order resource doesn't have an index action, so we current user 
+    # cannot perform the action.
+    assert !typus_user.can_perform?('Order', 'index')
+
+    # 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 })
+
+  end
+
+  def test_editor_role_settings
+
+    typus_user = typus_users(:editor)
+    assert_equal 'editor', typus_user.role
+
+    %w( Category Comment Git Post TypusUser ).each do |model|
+      assert typus_user.resources.map(&:first).include?(model)
+    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) }
+
+    # 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) }
+
+    # 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) }
+
+    # 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) }
+
+  end
+
+  def test_designer_role_settings
+
+    typus_user = typus_users(:designer)
+    assert_equal 'designer', typus_user.role
+
+    models = %w( Category Comment Post )
+    assert_equal models, typus_user.resources.map(&:first).sort
+
+    # 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) }
+
+    # 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) }
+
+    # Post: read
+    %w( read ).each { |action| assert typus_user.can_perform?(Post, action) }
+    %w( create update delete ).each { |action| assert !typus_user.can_perform?(Post, action) }
+
+  end
+
+end

data/test/unit/typus_user_test.rb

@@ -0,0 +1,177 @@
+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] }
+    @typus_user = TypusUser.new(@data)
+  end
+
+  def test_should_verify_typus_user_attributes
+    %w( first_name last_name email role salt crypted_password ).each do |attribute|
+      assert TypusUser.instance_methods.include?(attribute)
+    end
+  end
+
+  def test_should_verify_email_format
+    @typus_user.email = 'admin'
+    assert @typus_user.invalid?
+    assert @typus_user.errors.invalid?(:email)
+  end
+
+  def test_should_verify_email_is_not_valid
+    email = <<-END
+this_is_chelm@example.com
+<script>location.href="http://spammersite.com"</script>
+END
+    @typus_user.email = email
+    assert @typus_user.invalid?
+    assert @typus_user.errors.invalid?(:email)
+  end
+
+  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
+
+  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?
+    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)
+    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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  def test_should_verify_confirmation_of_password
+
+    @typus_user.password = '12345678'
+    @typus_user.password_confirmation = '87654321'
+    assert @typus_user.invalid?
+    assert @typus_user.errors.invalid?(:password)
+
+=begin
+
+    # FIXME
+
+    @typus_user.password = '12345678'
+    @typus_user.password_confirmation = nil
+    assert @typus_user.invalid?
+    assert @typus_user.errors.invalid?(:password)
+
+=end
+
+    @typus_user.password = '12345678'
+    @typus_user.password_confirmation = ''
+    assert @typus_user.invalid?
+    assert @typus_user.errors.invalid?(:password)
+
+  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
+
+  def test_should_return_full_name
+    assert_equal "#{@typus_user.email} (#{@typus_user.role})", @typus_user.full_name(:display_role => true)
+    assert_equal "#{@typus_user.email}", @typus_user.full_name
+  end
+
+  def test_should_return_full_name_with_role
+    @typus_user.first_name = 'John'
+    @typus_user.last_name = 'Smith'
+    assert_equal "John Smith (#{@typus_user.role})", @typus_user.full_name(:display_role => true)
+    assert_equal 'John Smith', @typus_user.full_name
+  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
+
+  def test_should_verify_typus_user_can_be_created
+    assert_difference 'TypusUser.count' do
+      TypusUser.create(@data)
+    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('demo@example.com', 'XXXXXXXX').valid?
+    assert TypusUser.generate('demo@example.com', 'XXXX').invalid?
+  end
+
+end

data/test/vendor/active_record_test.rb

@@ -0,0 +1,18 @@
+require 'test/helper'
+
+class ActiveRecordTest < ActiveSupport::TestCase
+
+  def test_should_verify_to_dom
+
+    assert_equal "typus_user_new", TypusUser.new.to_dom
+
+    typus_user = typus_users(:admin)
+    assert_equal "typus_user_#{typus_user.id}", typus_user.to_dom
+
+    assert_equal "prefix_typus_user_#{typus_user.id}", typus_user.to_dom(:prefix => 'prefix')
+    assert_equal "typus_user_#{typus_user.id}_suffix", typus_user.to_dom(:suffix => 'suffix')
+    assert_equal "prefix_typus_user_#{typus_user.id}_suffix", typus_user.to_dom(:prefix => 'prefix', :suffix => 'suffix')
+
+  end
+
+end

data/test/vendor/paginator_test.rb

@@ -0,0 +1,138 @@
+require 'test/helper'
+
+# require 'paginator'
+
+class PaginatorTest < ActiveSupport::TestCase
+
+  PER_PAGE = 10
+
+  def setup
+    @data = (0..43).to_a
+    @pager = Paginator.new(@data.size, PER_PAGE) do |offset,per_page|
+      @data[offset,per_page]
+    end
+  end
+
+  def test_initializing_paginator_raises_exception
+    assert_raises(Paginator::MissingSelectError) do
+      @pager = Paginator.new(@data.size, PER_PAGE)
+    end
+  end
+
+  def test_can_get_last_page_from_page_object
+    assert_equal @pager.last, @pager.page(2).last
+  end
+
+  def test_can_get_first_page_from_page_object
+    assert_equal @pager.first, @pager.page(2).first
+  end
+
+  def test_does_not_exceed_per_page
+    @pager.each do |page|
+      assert page.items.size <= PER_PAGE
+    end
+  end
+
+  def test_only_last_page_has_less_items
+    @pager.each do |page|
+      if page != @pager.last
+        assert page.items.size <= PER_PAGE
+      else
+        assert page.items.size < PER_PAGE
+      end
+    end
+  end
+
+  def test_returns_correct_first_page
+    assert_equal @pager.page(1).number, @pager.first.number
+  end
+
+  def test_returns_correct_last_page
+    assert_equal @pager.page(5).number, @pager.last.number
+  end
+
+  def test_last_page_has_no_next_page
+    assert !@pager.last.next?
+    assert !@pager.last.next
+  end
+
+  def test_first_page_has_no_prev_page
+    assert !@pager.first.prev?
+    assert !@pager.first.prev
+  end
+
+  def test_page_enumerable
+    @pager.each do |page|
+      assert page
+      page.each do |item|
+        assert item
+      end
+      page.each_with_index do |item, index|
+        assert_equal page.items[index], item
+      end
+      assert_equal page.items, page.inject([]) {|list, item| list << item }
+    end
+  end
+
+  def test_each_with_index
+    page_offset = 0
+    @pager.each_with_index do |page, page_index|
+      assert page
+      assert_equal page_offset, page_index
+      item_offset = 0
+      page.each_with_index do |item, item_index|
+        assert item
+        assert_equal item_offset, item_index
+        item_offset += 1
+      end
+      page_offset += 1
+    end
+  end
+
+  def test_number_of_pages
+    assert_equal 5, @pager.number_of_pages
+  end
+
+  def test_passing_block_to_initializer_with_arity_of_two_yields_per_page
+    pager = Paginator.new(20,2) do |offset,per_page|
+      assert_equal 2, per_page
+    end
+    pager.page(1).items
+  end
+
+  def test_passing_block_to_initializer_with_arity_of_one_does_not_yield_per_page
+    pager = Paginator.new(20,2) do |offset|
+      assert_equal 0, offset
+    end
+    pager.page(1).items
+  end
+
+  def test_page_object_knows_first_and_last_item_numbers
+    items = (1..11).to_a
+    pager = Paginator.new(items.size,3) do |offset, per_page|
+      items[offset, per_page]
+    end
+    page = pager.page(1)
+    assert_equal 1, page.first_item_number
+    assert_equal 3, page.last_item_number
+    page = pager.page(2)
+    assert_equal 4, page.first_item_number
+    assert_equal 6, page.last_item_number
+    page = pager.page(3)
+    assert_equal 7, page.first_item_number
+    assert_equal 9, page.last_item_number
+    page = pager.page(4)
+    assert_equal 10, page.first_item_number
+    assert_equal 11, page.last_item_number
+  end
+
+end
+
+class PaginatorTestWithMathN < PaginatorTest
+
+  def setup
+    require 'mathn'
+    super
+  end
+
+end