incline 0.1.5

data/test/models/incline/access_group_group_member_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module Incline
+  class AccessGroupGroupMemberTest < ActiveSupport::TestCase
+    def setup
+      @group1 = incline_access_groups(:one)
+      @group2 = incline_access_groups(:two)
+      @group3 = incline_access_groups(:three)
+      @item = Incline::AccessGroupGroupMember.new(group_id: @group1.id, member_id: @group2.id)
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require group_id' do
+      assert_required @item, :group_id
+    end
+
+    test 'should require member_id' do
+      assert_required @item, :member_id
+    end
+
+    test 'member_id should be unique within group_id scope' do
+      assert_uniqueness @item, :member_id, false, group_id: @group3.id
+    end
+
+
+  end
+end

data/test/models/incline/access_group_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Incline
+  class AccessGroupTest < ActiveSupport::TestCase
+
+    def setup
+      @group = Incline::AccessGroup.new(name: 'Group X')
+      @group1 = incline_access_groups(:one)
+    end
+
+    test 'should be valid' do
+      assert @group.valid?
+    end
+
+    test 'should require name' do
+      assert_required @group, :name
+    end
+
+    test 'name should not be too long' do
+      assert_max_length @group, :name, 100
+    end
+
+    test 'name should be unique' do
+      assert_uniqueness @group, :name
+    end
+
+    test 'should allow members' do
+      # must save before adding.
+      @group.save!
+      @group.reload
+
+      @group.groups << @group1
+
+      assert @group.valid?
+
+      @group.save!
+
+      # group-x should have one member and group-1 should belong to one group.
+      assert_equal 1, @group.groups(true).count
+      assert_equal 1, @group1.memberships(true).count
+
+      # group-x has group-1 as a member and group-1 is a member of group-x.
+      assert @group.groups.include?(@group1)
+      assert @group1.memberships.include?(@group)
+
+      # group-1 equates to both group-1 and group-x for effective groups.
+      assert @group1.effective_groups.include?(@group1)
+      assert @group1.effective_groups.include?(@group)
+
+      # group-x equates to group-x but not group-1 for effective groups.
+      assert @group.effective_groups.include?(@group)
+      assert_not @group.effective_groups.include?(@group1)
+
+      # group-1 belongs to group-x but group-x does not belong to group-1.
+      assert @group1.belongs_to?(@group)
+      assert_not @group.belongs_to?(@group1)
+    end
+
+  end
+end

data/test/models/incline/access_group_user_member_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module Incline
+  class AccessGroupUserMemberTest < ActiveSupport::TestCase
+    def setup
+      @group1 = incline_access_groups(:one)
+      @group2 = incline_access_groups(:two)
+      @user = incline_users(:one)
+      @item = Incline::AccessGroupUserMember.new(group_id: @group1.id, member_id: @user.id)
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require group_id' do
+      assert_required @item, :group_id
+    end
+
+    test 'should require member_id' do
+      assert_required @item, :member_id
+    end
+
+    test 'member_id should be unique within group_id scope' do
+      assert_uniqueness @item, :member_id, false, group_id: @group2.id
+    end
+
+  end
+end

data/test/models/incline/action_group_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module Incline
+  class ActionGroupTest < ActiveSupport::TestCase
+
+    def setup
+      @item = Incline::ActionGroup.new(action_security: incline_action_securities(:one), access_group: incline_access_groups(:one))
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require action_security' do
+      assert_required @item, :action_security
+    end
+
+    test 'should require access_group' do
+      assert_required @item, :access_group
+    end
+
+    test 'access_group should be unique within action_security' do
+      assert_uniqueness @item, :access_group, action_security: incline_action_securities(:two)
+    end
+
+  end
+end

data/test/models/incline/action_security_test.rb

@@ -0,0 +1,176 @@
+require 'test_helper'
+
+module Incline
+  class ActionSecurityTest < ActiveSupport::TestCase
+
+    class EveryoneController < ActionController::Base
+      allow_anon true
+    end
+
+    class AnonOnlyController < ActionController::Base
+      require_anon true
+    end
+
+    class AdminOnlyController < ActionController::Base
+      require_admin true
+    end
+
+    class AnyUserController < ActionController::Base
+
+    end
+
+    class MixedController < ActionController::Base
+      allow_anon :index
+      require_anon :new, :create
+      require_admin :edit, :update, :destroy
+      # And the final CRUD action (:show) is currently allowed by any logged in user.
+    end
+
+    def setup
+      @item = Incline::ActionSecurity.new(path: '/things', controller_name: 'things', action_name: 'index')
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require path' do
+      assert_required @item, :path
+    end
+
+    test 'should require controller_name' do
+      assert_required @item, :controller_name
+    end
+
+    test 'should require action_name' do
+      assert_required @item, :action_name
+    end
+
+    test 'should limit length of controller_name' do
+      assert_max_length @item, :controller_name, 200
+    end
+
+    test 'should limit length of action_name' do
+      assert_max_length @item, :action_name, 200
+    end
+
+    test 'action_name should be unique within controller_name' do
+      assert_uniqueness @item, :action_name, controller_name: 'other_things'
+    end
+
+    test 'names are stored in lowercase' do
+      @item.controller_name = 'THINGS'
+      assert_equal 'THINGS', @item.controller_name
+      @item.save!
+      assert_equal 'things', @item.controller_name
+      @item.action_name = 'SHOW'
+      assert_equal 'SHOW', @item.action_name
+      @item.save!
+      assert_equal 'show', @item.action_name
+    end
+
+    test 'allow_custom? works correctly' do
+      assert @item.allow_custom?
+      @item.require_admin = true
+      assert_not @item.allow_custom?
+      @item.require_admin = false
+      @item.require_anon = true
+      assert_not @item.allow_custom?
+      @item.require_anon = false
+      @item.allow_anon = true
+      assert_not @item.allow_custom?
+      @item.allow_anon = false
+      assert @item.allow_custom?
+    end
+
+    test 'short_permitted works correctly' do
+
+      {
+          nil => 'Users',
+          require_admin: 'Admins',
+          require_anon: 'Anon',
+          allow_anon: 'Everyone'
+      }.each do |attr,ret|
+        @item.send("#{attr}=", true) if attr
+        assert_equal ret, @item.short_permitted
+        @item.non_standard = true
+        assert_equal ret + '*', @item.short_permitted
+        @item.non_standard = false
+        @item.send("#{attr}=", false) if attr
+      end
+      assert_equal 'Users', @item.short_permitted
+
+      @item.groups << incline_access_groups(:one)
+      assert_equal 'Custom', @item.short_permitted
+    end
+
+    test 'anon_only test' do
+      %w(index new create show edit update destroy).each do |action|
+        @item = Incline::ActionSecurity.new(path: '/', controller_name: 'incline/action_security_test/anon_only', action_name: action)
+        @item.update_flags
+        assert_not @item.unknown_controller?
+        assert @item.require_anon?
+        assert_not @item.allow_anon?
+        assert_not @item.require_admin?
+        assert_not @item.allow_custom?
+      end
+    end
+
+    test 'everyone test' do
+      %w(index new create show edit update destroy).each do |action|
+        @item = Incline::ActionSecurity.new(path: '/', controller_name: 'incline/action_security_test/everyone', action_name: action)
+        @item.update_flags
+        assert_not @item.unknown_controller?
+        assert_not @item.require_anon?
+        assert @item.allow_anon?
+        assert_not @item.require_admin?
+        assert_not @item.allow_custom?
+      end
+    end
+
+    test 'admin_only test' do
+      %w(index new create show edit update destroy).each do |action|
+        @item = Incline::ActionSecurity.new(path: '/', controller_name: 'incline/action_security_test/admin_only', action_name: action)
+        @item.update_flags
+        assert_not @item.unknown_controller?
+        assert_not @item.require_anon?
+        assert_not @item.allow_anon?
+        assert @item.require_admin?
+        assert_not @item.allow_custom?
+      end
+    end
+
+    test 'any_user test' do
+      %w(index new create show edit update destroy).each do |action|
+        @item = Incline::ActionSecurity.new(path: '/', controller_name: 'incline/action_security_test/any_user', action_name: action)
+        @item.update_flags
+        assert_not @item.unknown_controller?
+        assert_not @item.require_anon?
+        assert_not @item.allow_anon?
+        assert_not @item.require_admin?
+        assert @item.allow_custom?
+      end
+    end
+
+    test 'mixed test' do
+      {   #           anon    allow   admin   user
+          index:    [ false,  true,   false,  false ],
+          new:      [ true,   false,  false,  false ],
+          create:   [ true,   false,  false,  false ],
+          show:     [ false,  false,  false,  true ],
+          edit:     [ false,  false,  true,   false ],
+          update:   [ false,  false,  true,   false ],
+          destroy:  [ false,  false,  true,   false ]
+      }.each do |action,(anon,allow,admin,user)|
+        @item = Incline::ActionSecurity.new(path: '/', controller_name: 'incline/action_security_test/mixed', action_name: action)
+        @item.update_flags
+        assert_not @item.unknown_controller?
+        assert_equal anon,  @item.require_anon?
+        assert_equal allow, @item.allow_anon?
+        assert_equal admin, @item.require_admin?
+        assert_equal user,  @item.allow_custom?
+      end
+    end
+
+  end
+end

data/test/models/incline/contact_message_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module Incline
+  class ContactMessageTest < ActiveSupport::TestCase
+
+    def setup
+      @item = Incline::ContactMessage.new(
+          your_name: 'Jane Doe',
+          your_email: 'janed@example.com',
+          related_to: 'Other',
+          subject: 'Just a test',
+          body: 'This is just a test message.',
+          recaptcha: Incline::Recaptcha::DISABLED
+      )
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require your_name' do
+      assert_required @item, :your_name
+    end
+
+    test 'should require your_email' do
+      assert_required @item, :your_email
+    end
+
+    test 'should require related_to' do
+      assert_required @item, :related_to
+    end
+
+    test 'should require subject when related_to is other' do
+      @item.related_to = 'other'
+      assert_required @item, :subject
+    end
+
+    test 'should not require subject when related_to is anything else' do
+      @item.related_to = 'something'
+      assert @item.valid?
+      @item.subject = nil
+      assert @item.valid?
+      @item.subject = ''
+      assert @item.valid?
+      @item.subject = '   '
+      assert @item.valid?
+    end
+
+    test 'should require body' do
+      assert_required @item, :body
+    end
+
+    test 'should require recaptcha' do
+      assert_required @item, :recaptcha
+    end
+
+    test 'should validate recaptcha' do
+      assert_recaptcha_validation @item, :recaptcha
+    end
+
+    test 'should validate email' do
+      assert_email_validation @item, :your_email
+    end
+
+  end
+end

data/test/models/incline/disable_info_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module Incline
+  class DisableInfoTest < ActiveSupport::TestCase
+
+    def setup
+      @item = Incline::DisableInfo.new(user: incline_users(:one), reason: 'For testing')
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require user' do
+      assert_required @item, :user, nil, /must be provided/
+    end
+
+    test 'should require reason' do
+      assert_required @item, :reason
+    end
+
+    test 'user must be enabled' do
+      @item.user = incline_users(:disabled)
+      assert_not @item.valid?
+      assert @item.errors[:user].to_s =~ /must be enabled/
+    end
+
+  end
+end

data/test/models/incline/password_reset_request_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Incline
+  class PasswordResetRequestTest < ActiveSupport::TestCase
+
+    def setup
+      @item = Incline::PasswordResetRequest.new(
+          email: 'user@example.com',
+          recaptcha: Incline::Recaptcha::DISABLED
+      )
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require email' do
+      assert_required @item, :email
+    end
+
+    test 'should require recaptcha' do
+      assert_required @item, :recaptcha
+    end
+
+    test 'email should be validated' do
+      assert_email_validation @item, :email
+    end
+
+    test 'recaptcha should be validated' do
+      assert_recaptcha_validation @item, :recaptcha
+    end
+
+
+  end
+end

data/test/models/incline/password_reset_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Incline
+  class PasswordResetTest < ActiveSupport::TestCase
+
+    def setup
+      @item = Incline::PasswordReset.new(
+          password: 'password',
+          password_confirmation: 'password',
+          recaptcha: Incline::Recaptcha::DISABLED
+      )
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require password' do
+      assert_required @item, :password
+    end
+
+    test 'should require minimum password length' do
+      @item.password = @item.password_confirmation = 'a' * 8
+      assert @item.valid?
+
+      @item.password = @item.password_confirmation = 'a' * 7
+      assert_not @item.valid?
+      assert @item.errors[:password].to_s =~ /is too short/
+    end
+
+    test 'should require password_confirmation' do
+      assert_required @item, :password_confirmation
+    end
+
+    test 'password_confirmation should match password' do
+      @item.password_confirmation = 'a' * 8
+      assert_not @item.valid?
+      assert @item.errors[:password_confirmation].to_s =~ /doesn't match/
+    end
+
+    test 'should require recaptcha' do
+      assert_required @item, :recaptcha
+    end
+
+    test 'should validate recaptcha' do
+      assert_recaptcha_validation @item, :recaptcha
+    end
+
+
+  end
+end

data/test/models/incline/user_login_history_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Incline
+  class UserLoginHistoryTest < ActiveSupport::TestCase
+    def setup
+      @user = incline_users(:one)
+      @item = Incline::UserLoginHistory.new(user: @user, ip_address: '1.2.3.4')
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require user' do
+      assert_required @item, :user
+    end
+
+    test 'should require ip_address' do
+      assert_required @item, :ip_address
+    end
+
+    test 'should validate ip_address' do
+      assert_ip_validation @item, :ip_address, :deny_mask
+    end
+
+    test 'message should not be too long' do
+      assert_max_length @item, :message, 200
+    end
+
+  end
+end

data/test/models/incline/user_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+module Incline
+  class UserTest < ActiveSupport::TestCase
+    def setup
+      @item = Incline::User.new(
+          name: 'John Wayne',
+          email: 'j.wayne@example.com',
+          password: 'password',
+          password_confirmation: 'password',
+          recaptcha: Incline::Recaptcha::DISABLED
+      )
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require name' do
+      assert_required @item, :name
+    end
+
+    test 'should require email' do
+      assert_required @item, :email
+    end
+
+    test 'should require recaptcha' do
+      assert_required @item, :recaptcha
+    end
+
+    test 'should validate recaptcha' do
+      assert_recaptcha_validation @item, :recaptcha
+    end
+
+    test 'recaptcha not required for updates' do
+      @item.save!
+      @item.recaptcha = nil
+      assert @item.valid?
+    end
+
+    test 'name should not be too long' do
+      assert_max_length @item, :name, 100
+    end
+
+    test 'email should not be too long' do
+      assert_max_length @item, :email, 250, end_with: '@example.com'
+    end
+
+    test 'email should be unique' do
+      assert_uniqueness @item, :email
+    end
+
+    test 'email should be validated' do
+      assert_email_validation @item, :email
+    end
+
+    test 'email should be saved lowercase' do
+      mixed_case_email = 'JohnDoe@Example.COM'
+      @item.email = mixed_case_email
+      assert @item.valid?
+      assert_equal mixed_case_email, @item.email
+      @item.save!
+      assert_equal mixed_case_email.downcase, @item.email
+    end
+
+    test 'password should have min length' do
+      pwd = 'a' * 8
+      @item.password = @item.password_confirmation = pwd
+      assert @item.valid?
+      pwd = 'a' * 7
+      @item.password = @item.password_confirmation = pwd
+      assert_not @item.valid?
+    end
+
+    test 'password should not be blank' do
+      @item.password = @item.password_confirmation = ' ' * 8
+      assert_not @item.valid?
+    end
+
+    test 'password_confirmation must match' do
+      @item.password_confirmation = 'a' * 8
+      assert_not @item.valid?
+    end
+
+    test 'authenticated should return false for nil digest' do
+      assert_not @item.authenticated?(:remember, '')
+    end
+
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,42 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../../test/dummy/config/environment.rb",  __FILE__)
+ActiveRecord::Migrator.migrations_paths = [File.expand_path("../../test/dummy/db/migrate", __FILE__)]
+ActiveRecord::Migrator.migrations_paths << File.expand_path('../../db/migrate', __FILE__)
+require "rails/test_help"
+
+require 'byebug'
+
+# Filter out Minitest backtrace while allowing backtrace from other libraries
+# to be shown.
+Minitest.backtrace_filter = Minitest::BacktraceFilter.new
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# Load fixtures from the engine
+if ActiveSupport::TestCase.respond_to?(:fixture_path=)
+  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
+  ActionDispatch::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
+  ActiveSupport::TestCase.fixtures :all
+end
+
+class MsSqlTestConn < ActiveRecord::Base
+  self.abstract_class = true
+
+  cfg = ActiveRecord::Base.configurations['mssql_test']
+  if cfg
+    begin
+      establish_connection cfg
+    rescue TinyTds::Error
+      remove_connection
+    end
+  end
+
+  def self.skip_tests?
+    self.connection.class.name != 'ActiveRecord::ConnectionAdapters::SQLServerAdapter'
+  end
+
+end
+