typus 3.0.12 → 3.1.0.rc1

data/test/app/mailers/admin/mailer_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class Admin::MailerTest < ActiveSupport::TestCase
+
+  test "reset_password_link" do
+    @typus_user = Factory.build(:typus_user, :token => "qswed3-64g3fb")
+    @url = "http://test.host/admin/account/#{@typus_user.token}"
+    @email = Admin::Mailer.reset_password_link(@typus_user, @url)
+
+    assert_nil Admin::Mailer.default[:from]
+    assert @email.to.include?(@typus_user.email)
+
+    expected = "[#{Typus.admin_title}] Reset password"
+    assert_equal expected, @email.subject
+    assert_equal "text/plain", @email.mime_type
+
+    assert_match @url, @email.body.encoded
+  end
+
+end

data/test/app/models/admin_user_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+##
+# Here we test:
+#
+# - Typus::Orm::ActiveRecord::AdminUserV2
+#
+class AdminUserTest < ActiveSupport::TestCase
+
+  test "token changes everytime we save the user" do
+    admin_user = Factory(:admin_user)
+    first_token = admin_user.token
+    admin_user.save
+    second_token = admin_user.token
+    assert !first_token.eql?(second_token)
+  end
+
+  test "mass_assignment" do
+    assert TypusUser.attr_protected[:default].include?(:status)
+  end
+
+end

data/test/app/models/typus_user_roles_test.rb

@@ -0,0 +1,125 @@
+require "test_helper"
+
+class TypusUserRolesTest < ActiveSupport::TestCase
+
+  test "configuration roles" do
+    assert_equal %w(admin designer disabled editor), Typus::Configuration.roles.map(&:first).sort
+  end
+
+  context "admin" do
+
+    setup do
+      @typus_user = Factory(:typus_user)
+    end
+
+    should "verify models access" do
+      expected = ["Article::Entry",
+                  "Asset",
+                  "Bird",
+                  "Case",
+                  "Category",
+                  "Comment",
+                  "Dog",
+                  "Entry",
+                  "Git",
+                  # "Hit",
+                  "ImageHolder",
+                  "Invoice",
+                  "Order",
+                  "Page",
+                  "Post",
+                  "Project",
+                  "ProjectCollaborator",
+                  "Status",
+                  "TypusUser",
+                  "User",
+                  "View",
+                  "WatchDog"]
+      assert_equal expected, @typus_user.resources.map(&:first).sort
+    end
+
+    should_eventually "verify resources without actions related are removed" do
+      assert !@typus_user.resources.map(&:first).include?('Order')
+    end
+
+    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
+
+    should "verify we can perform action on resource" do
+      assert @typus_user.can?('index', 'Status', { :special => true })
+    end
+
+    should "verify we cannot perform action on resource" do
+      assert @typus_user.cannot?('show', 'Status', { :special => true })
+    end
+
+    should_eventually "verify we cannot perform actions on resources which don't have that action defined" do
+      assert @typus_user.cannot?('index', 'Order')
+    end
+
+  end
+
+  context "editor" do
+
+    setup do
+      @typus_user = Factory(:typus_user, :role => "editor")
+    end
+
+    should "verify models access" do
+      expected = %w(Category Comment Git Post TypusUser View)
+      assert_equal expected, @typus_user.resources.map(&:first).sort
+    end
+
+    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
+
+    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
+
+    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
+
+    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
+
+  context "designer" do
+
+    setup do
+      @typus_user = Factory(:typus_user, :role => "designer")
+    end
+
+    should "verify models access" do
+      expected = %w(Category Comment Post)
+      assert_equal expected, @typus_user.resources.map(&:first).sort
+    end
+
+    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
+
+    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
+
+    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
+
+  end
+
+end

data/test/app/models/typus_user_test.rb

@@ -0,0 +1,145 @@
+require "test_helper"
+
+##
+# Here we test:
+#
+# - Typus::Orm::ActiveRecord::AdminUserV1
+#
+class TypusUserTest < ActiveSupport::TestCase
+
+  test "validate email" do
+    assert Factory.build(:typus_user, :email => "dong").invalid?
+    assert Factory.build(:typus_user, :email => "john@example.com").valid?
+    assert Factory.build(:typus_user, :email => nil).invalid?
+  end
+
+  test "validate :role" do
+    assert Factory.build(:typus_user, :role => nil).invalid?
+  end
+
+  test "validate :password" do
+    assert Factory.build(:typus_user, :password => "0"*5).invalid?
+    assert Factory.build(:typus_user, :password => "0"*6).valid?
+    assert Factory.build(:typus_user, :password => "0"*40).valid?
+    assert Factory.build(:typus_user, :password => "0"*41).invalid?
+  end
+
+  should "not allow_mass_assignment_of :status" do
+    assert TypusUser.attr_protected[:default].include?(:status)
+  end
+
+  should "verify columns" do
+    expected = %w(id first_name last_name email role status salt crypted_password token preferences created_at updated_at).sort
+    output = TypusUser.columns.map(&:name).sort
+    assert_equal expected, output
+  end
+
+  test "generate" do
+    assert TypusUser.generate.invalid?
+
+    options = { :email => 'demo@example.com' }
+    assert TypusUser.generate(options).valid?
+
+    options = { :email => 'demo@example.com', :password => 'XXXXXXXX' }
+    assert TypusUser.generate(options).valid?
+
+    options = { :email => 'demo@example.com', :role => 'admin' }
+    assert TypusUser.generate(options).valid?
+  end
+
+  context "TypusUser" do
+
+    setup do
+      @typus_user = Factory(:typus_user)
+    end
+
+    should "verify salt never changes" do
+      expected = @typus_user.salt
+      @typus_user.update_attributes(:password => '11111111', :password_confirmation => '11111111')
+      assert_equal expected, @typus_user.salt
+    end
+
+    should "verify authenticated? returns true or false" do
+      assert @typus_user.authenticated?('12345678')
+      assert !@typus_user.authenticated?('87654321')
+    end
+
+    should "verify preferences are nil by default" do
+      assert @typus_user.preferences.nil?
+    end
+
+    should "return default_locale when no preferences are set" do
+      assert @typus_user.locale.eql?(:en)
+    end
+
+    should "be able to set a locale" do
+      @typus_user.locale = :jp
+
+      expected = {:locale => :jp}
+      assert_equal expected, @typus_user.preferences
+      assert @typus_user.locale.eql?(:jp)
+    end
+
+    should "be able to set preferences" do
+      @typus_user.preferences = {:chunky => "bacon"}
+      assert @typus_user.preferences.present?
+    end
+
+    should "set locale preference without overriding previously set preferences" do
+      @typus_user.preferences = {:chunky => "bacon"}
+      @typus_user.locale = :jp
+
+      expected = {:locale => :jp, :chunky => "bacon"}
+      assert_equal expected, @typus_user.preferences
+    end
+
+  end
+
+  test "admin gets a list of all applications expect MongoDB becuase is disabled" do
+    typus_user = Factory.build(:typus_user)
+    # assert_equal Typus.applications, typus_user.applications
+    assert_equal Typus.applications.reject { |i| i.eql?("MongoDB") }, typus_user.applications
+  end
+
+  test "admin gets a list of application resources for CRUD Extended application" do
+    typus_user = Factory.build(:typus_user)
+    assert_equal %w(Asset Category Comment Page Post), typus_user.application("CRUD Extended")
+  end
+
+  test "admin gets a list of application resources for Admin application" do
+    typus_user = Factory.build(:typus_user)
+    assert_equal %w(TypusUser), typus_user.application("Admin")
+  end
+
+  test "editor get a list of all applications" do
+    typus_user = Factory.build(:typus_user, :role => "editor")
+    assert_equal ["Admin", "CRUD Extended"], typus_user.applications
+  end
+
+  test "editor gets a list of application resources" do
+    typus_user = Factory.build(:typus_user, :role => "editor")
+    assert_equal %w(Category Comment Post), typus_user.application("CRUD Extended")
+    assert_equal %w(TypusUser), typus_user.application("Admin")
+  end
+
+  test "user owns a resource" do
+    typus_user = Factory.build(:typus_user)
+    resource = Factory.build(:post, :typus_user => typus_user)
+    assert typus_user.owns?(resource)
+  end
+
+  test "user does not own a resource" do
+    typus_user = Factory(:typus_user)
+    resource = Factory(:post, :typus_user => Factory(:typus_user))
+    assert !typus_user.owns?(resource)
+  end
+
+  test "token changes everytime we save the user" do
+    admin_user = Factory(:typus_user)
+    first_token = admin_user.token
+    admin_user.save
+    second_token = admin_user.token
+    assert !first_token.eql?(second_token)
+  end
+
+end

data/test/app/models/user_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+##
+# Here we test:
+#
+# - Typus::Orm::ActiveRecord::User::InstanceMethods
+#
+class UserTest < ActiveSupport::TestCase
+
+  test "to_label" do
+    user = Factory.build(:user)
+    assert_equal user.email, user.to_label
+
+    user = Factory.build(:user, :first_name => "John")
+    assert_equal "John", user.to_label
+
+    user = Factory.build(:user, :last_name => "Locke")
+    assert_equal "Locke", user.to_label
+
+    user = Factory.build(:user, :first_name => "John", :last_name => "Locke")
+    assert_equal "John Locke", user.to_label
+  end
+
+  test "can?" do
+    user = Factory.build(:user, :role => 'admin')
+    assert user.can?('delete', TypusUser)
+    assert !user.cannot?('delete', TypusUser)
+    assert user.can?('delete', 'TypusUser')
+    assert !user.cannot?('delete', 'TypusUser')
+  end
+
+  test "is_root?" do
+    user = Factory.build(:user, :role => 'admin')
+    assert user.is_root?
+    assert !user.is_not_root?
+  end
+
+end

data/test/config/routes_test.rb

@@ -0,0 +1,30 @@
+require "test_helper"
+
+class RoutesTest < ActiveSupport::TestCase
+
+  setup do
+    # @routes = Admin::Engine.routes.routes.map(&:name)
+    @routes = Rails.application.routes.routes.map(&:name)
+  end
+
+  should "have dashboard routes" do
+    expected = %w(admin_dashboard)
+    expected.each { |r| assert @routes.include?(r) }
+  end
+
+  should "have account routes" do
+    expected = %w(forgot_password_admin_account_index
+                  send_password_admin_account_index
+                  admin_account_index
+                  new_admin_account
+                  admin_account)
+
+    expected.each { |r| assert @routes.include?(r) }
+  end
+
+  should "have session routes" do
+    expected = %w(new_admin_session admin_session)
+    expected.each { |r| assert @routes.include?(r) }
+  end
+
+end

data/test/factories.rb

@@ -0,0 +1,134 @@
+##
+# Models Provided by Typus!
+##
+
+Factory.define :admin_user do |f|
+  f.sequence(:email) { |n| "admin+#{n}@example.com" }
+  f.password "XXXXXXXX"
+  f.role "admin"
+end
+
+##
+# CRUD
+##
+
+Factory.define :entry do |f|
+  f.sequence(:title) { |n| "Entry##{n}" }
+  f.content "Body of the entry"
+end
+
+Factory.define :case do |f|
+  f.sequence(:title) { |n| "Case##{n}" }
+  f.content "Body of the entry"
+end
+
+##
+# CRUD Extended
+##
+
+Factory.define :asset do |f|
+  f.sequence(:caption) { |n| "Asset##{n}" }
+  f.dragonfly File.new("#{Rails.root}/public/images/rails.png")
+  f.dragonfly_required File.new("#{Rails.root}/public/images/rails.png")
+  f.paperclip File.new("#{Rails.root}/public/images/rails.png")
+  f.paperclip_required File.new("#{Rails.root}/public/images/rails.png")
+end
+
+Factory.define :category do |f|
+  f.sequence(:name) { |n| "Category##{n}" }
+end
+
+Factory.define :comment do |f|
+  f.sequence(:name) { |n| "Comment##{n}" }
+  f.sequence(:email) { |n| "john+#{n}@example.com" }
+  f.body "Body of the comment"
+  f.association :post
+end
+
+Factory.define :page do |f|
+  f.sequence(:title) { |n| "Page##{n}" }
+  f.body "Content"
+end
+
+Factory.define :post do |f|
+  f.sequence(:title) { |n| "Post##{n}" }
+  f.body "Body"
+  f.status "published"
+end
+
+Factory.define :typus_user do |f|
+  f.sequence(:email) { |n| "user+#{n}@example.com" }
+  f.role "admin"
+  f.status true
+  f.token "1A2B3C4D5E6F"
+  f.password "12345678"
+end
+
+Factory.define :view do |f|
+  f.ip "127.0.0.1"
+  f.association :post
+  f.association :site
+end
+
+##
+# HasOne Association
+#
+
+Factory.define :invoice do |f|
+  f.sequence(:number) { |n| "Invoice##{n}" }
+  f.association :order
+end
+
+Factory.define :order do |f|
+  f.sequence(:number) { |n| "Order##{n}" }
+end
+
+##
+# HasManyThrough Association
+#
+
+Factory.define :user do |f|
+  f.sequence(:name) { |n| "User##{n}" }
+  f.sequence(:email) { |n| "user.#{n}@example.com" }
+  f.role "admin"
+  f.token "qw1rd3-1w3f5b"
+end
+
+Factory.define :project do |f|
+  f.sequence(:name) { |n| "Project##{n}" }
+  f.association :user
+end
+
+Factory.define :project_collaborators do |f|
+  f.association :user
+  f.association :project
+end
+
+##
+# Polymorphic
+##
+
+Factory.define :animal do |f|
+  f.sequence(:name) { |n| "Animal##{n}" }
+end
+
+Factory.define :bird do |f|
+  f.sequence(:name) { |n| "Bird##{n}" }
+end
+
+Factory.define :dog do |f|
+  f.sequence(:name) { |n| "Dog##{n}" }
+end
+
+Factory.define :image_holder do |f|
+  f.sequence(:name) { |n| "ImageHolder##{n}" }
+end
+
+##
+# Contexts
+##
+
+Factory.define :site do |f|
+  f.sequence(:name) { |n| "Site##{n}" }
+  f.sequence(:domain) { |n| "site#{n}.local" }
+end