incline 0.1.5

data/test/extensions/session_extensions_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class SessionExtensionsTest < ActionDispatch::IntegrationTest
+
+  VIEW_METHODS = [
+      :user_id_cookie,
+      :user_token_cookie,
+      :current_user,
+      :current_user?,
+      :logged_in?,
+      :system_admin?
+  ]
+
+  CONTROLLER_METHODS = [
+      :log_in,
+      :log_out,
+      :remember,
+      :forget
+  ]
+
+  # A broken mailer just to check for methods.
+  class TestMailer < ActionMailer::Base
+
+    def self.create_instance
+      new
+    end
+
+  end
+
+  test 'test has correct methods' do
+    VIEW_METHODS.each do |m|
+      assert respond_to?(m), "Test should respond to #{m.inspect}."
+    end
+    CONTROLLER_METHODS.each do |m|
+      assert_not respond_to?(m), "Test should not respond to #{m.inspect}."
+    end
+  end
+
+  test 'view has correct methods' do
+    view = ActionView::Base.new
+    VIEW_METHODS.each do |m|
+      assert view.respond_to?(m), "View should respond to #{m.inspect}."
+    end
+    CONTROLLER_METHODS.each do |m|
+      assert_not view.respond_to?(m), "View should not respond to #{m.inspect}."
+    end
+  end
+
+  test 'controller has correct methods' do
+    ctrlr = ActionController::Base.new
+    VIEW_METHODS.each do |m|
+      assert ctrlr.respond_to?(m), "Controller should respond to #{m.inspect}."
+    end
+    CONTROLLER_METHODS.each do |m|
+      assert ctrlr.respond_to?(m), "Controller should respond to #{m.inspect}."
+    end
+  end
+
+  test 'mailer has correct methods' do
+    mailer = TestMailer.create_instance
+    VIEW_METHODS.each do |m|
+      assert mailer.respond_to?(m), "Mailer should respond to #{m.inspect}."
+    end
+    CONTROLLER_METHODS.each do |m|
+      assert_not mailer.respond_to?(m), "Mailer should not respond to #{m.inspect}."
+    end
+  end
+
+end

data/test/extensions/string_extensions_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class StringExtensionsTest < ActiveSupport::TestCase
+
+  test 'string has to_hex_string and to_byte_string' do
+    s = 'hello'
+    assert s.respond_to?(:to_hex_string)
+    assert s.respond_to?(:to_byte_string)
+  end
+
+  test 'hex and byte conversion works' do
+    s_text = 'Hello World'
+    s_hex = '48656c6c6f20576f726c64'
+    assert_equal s_hex, s_text.to_hex_string
+    assert_equal s_text, s_hex.to_byte_string
+    s_text += s_hex
+    assert_equal s_text, s_text.to_hex_string.to_byte_string
+  end
+
+  test 'hex grouping works' do
+    s_text = 'Hello World'
+    s_hex = '48 65 6c 6c 6f 20 57 6f 72 6c 64'
+    assert_equal s_hex, s_text.to_hex_string(true)
+    assert_equal s_text, s_text.to_hex_string(true).to_byte_string
+    s_hex = '486 56c 6c6 f20 576 f72 6c6 4'
+    assert_equal s_hex, s_text.to_hex_string(3)
+    assert_equal s_text, s_text.to_hex_string(3).to_byte_string
+  end
+
+
+
+end

data/test/extensions/test_case_extensions_test.rb

@@ -0,0 +1,538 @@
+require 'test_helper'
+
+class TestCaseExtensionsTest < ActiveSupport::TestCase
+
+  TEST_TABLE_NAME = "test_table_#{SecureRandom.random_number(1<<16).to_s(16).rjust(4,'0')}"
+  TEST_TABLE_CLASS = TEST_TABLE_NAME.classify.to_sym
+
+  class TestRamModel
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :recaptcha, :email, :ip_any, :ip_mask, :ip_nomask, :session, :safe_name
+
+    validates :recaptcha, 'incline/recaptcha' => true
+    validates :email, 'incline/email' => true
+    validates :ip_any, 'incline/ip_address' => true
+    validates :ip_mask, 'incline/ip_address' => { require_mask: true }
+    validates :ip_nomask, 'incline/ip_address' => { no_mask: true }
+    validates :safe_name, 'incline/safe_name' => true
+  end
+
+  def with_db_model
+    begin
+      # Create a test table.
+      silence_stream STDOUT do
+        ActiveRecord::Migration::create_table TEST_TABLE_NAME do |t|
+          t.integer :group,       null: false
+          t.string  :name,        null: false,  limit: 30
+          t.string  :description,               limit: 100
+        end
+      end
+
+      # And then create a test model.
+      eval <<-EOM
+class #{TEST_TABLE_CLASS} < ActiveRecord::Base
+  self.table_name = #{TEST_TABLE_NAME.inspect}
+
+  validates :group,
+      presence: true
+
+  validates :name,
+      presence: true,
+      length: { minimum: 5, maximum: 30 },
+      uniqueness: { case_sensitive: false, scope: :group }
+
+  validates :description,
+      length: { maximum: 100 }
+end
+      EOM
+
+      model_class = self.class.const_get TEST_TABLE_CLASS
+      item = model_class.new(group: 1, name: 'Hello', description: 'World')
+
+      yield model_class, item
+    ensure
+      # Undefine the model class (or at least remove it from the Object namespace).
+      begin
+        self.class.send :remove_const, TEST_TABLE_CLASS
+      rescue
+        Incline::Log::error 'Failed to remove test model class.'
+      end
+
+      # Remove the table from the database.
+      begin
+        silence_stream STDOUT do
+          ActiveRecord::Migration::drop_table TEST_TABLE_NAME
+        end
+      rescue
+        Incline::Log::error 'Failed to drop test model table.'
+      end
+    end
+  end
+
+  def setup
+    @item = TestRamModel.new(session: 99, email: 'user@example.com', recaptcha: Incline::Recaptcha::DISABLED)
+  end
+
+  test 'have extension methods' do
+    assert respond_to?(:is_logged_in?)
+    assert respond_to?(:log_in_as)
+    assert respond_to?(:assert_required)
+    assert respond_to?(:assert_max_length)
+    assert respond_to?(:assert_min_length)
+    assert respond_to?(:assert_uniqueness)
+    assert respond_to?(:assert_recaptcha_validation)
+    assert respond_to?(:assert_email_validation)
+    assert respond_to?(:assert_ip_validation)
+    assert respond_to?(:assert_safe_name_validation)
+  end
+
+  test 'item should be valid' do
+    with_db_model do |klass,item|
+      assert item.valid?
+    end
+    assert @item.valid?
+  end
+
+  test 'item should require group' do
+    with_db_model do |klass,item|
+      assert_required item, :group
+    end
+  end
+
+  test 'item should require name' do
+    with_db_model do |klass,item|
+      assert_required item, :name
+    end
+  end
+
+  test 'item name should have min length' do
+    with_db_model do |klass,item|
+      assert_min_length item, :name, 5
+    end
+  end
+
+  test 'item name should have max length' do
+    with_db_model do |klass,item|
+      assert_max_length item, :name, 30
+    end
+  end
+
+  test 'item name should be unique within group' do
+    with_db_model do |klass,item|
+      assert_uniqueness item, :name, group: 2
+    end
+  end
+
+  test 'item description should have max length' do
+    with_db_model do |klass,item|
+      assert_max_length item, :description, 100
+    end
+  end
+
+  test 'item recaptcha should pass validation' do
+    assert_recaptcha_validation @item, :recaptcha
+  end
+
+  test 'item email should pass validation' do
+    assert_email_validation @item, :email
+  end
+
+  test 'item ips should pass validation' do
+    assert_ip_validation @item, :ip_any
+    assert_ip_validation @item, :ip_mask, :require_mask
+    assert_ip_validation @item, :ip_nomask, :deny_mask
+  end
+
+  test 'item safe_name should pass validation' do
+    assert_safe_name_validation @item, :safe_name, 10
+  end
+
+  test 'item description should not be required' do
+    with_db_model do |klass,item|
+      assert_raises(Minitest::Assertion) { assert_required item, :description }
+    end
+  end
+
+  test 'item description length is not limited to 50, 101, or 10' do
+    with_db_model do |klass,item|
+      assert_raises(Minitest::Assertion) { assert_max_length item, :description, 50 }
+      assert_raises(Minitest::Assertion) { assert_max_length item, :description, 101 }
+      assert_raises(Minitest::Assertion) { assert_min_length item, :description, 10 }
+    end
+  end
+
+  test 'item name is unique across descriptions' do
+    with_db_model do |klass,item|
+      assert_raises(Minitest::Assertion) { assert_uniqueness item, :name, description: 'something else' }
+    end
+  end
+
+  test 'item description is not a recaptcha field' do
+    with_db_model do |klass,item|
+      assert_raises(Minitest::Assertion) { assert_recaptcha_validation item, :description }
+    end
+
+  end
+
+  test 'item description is not an ip address field' do
+    with_db_model do |klass,item|
+      assert_raises(Minitest::Assertion) { assert_ip_validation item, :description }
+    end
+  end
+
+  test 'item description is not an email address field' do
+    with_db_model do |klass,item|
+      assert_raises(Minitest::Assertion) { assert_email_validation item, :description }
+    end
+  end
+
+  test 'item description is not a safe name field' do
+    with_db_model do |klass, item|
+      assert_raises(Minitest::Assertion) { assert_safe_name_validation item, :description }
+    end
+  end
+
+  DEFAULT_ACCESS_TEST_ANON = <<-EOC
+test "should not allow access to something for anonymous" do
+  path = foo_path
+  get(path)
+  assert_redirected_to incline.login_path
+end
+  EOC
+
+  DEFAULT_ACCESS_TEST_ANY = <<-EOC
+test "should not allow access to something for any user" do
+  user = incline_users(:basic)
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_redirected_to main_app.root_path
+end
+  EOC
+
+  DEFAULT_ACCESS_TEST_ADMIN = <<-EOC
+test "should allow access to something for admin user" do
+  user = incline_users(:admin)
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_response :success
+end
+  EOC
+
+  test 'access_tests_for default tests are good' do
+    valid = [ DEFAULT_ACCESS_TEST_ANON, DEFAULT_ACCESS_TEST_ANY, DEFAULT_ACCESS_TEST_ADMIN ].join
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path'
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects allow_anon' do
+    valid = [ <<-EOC, DEFAULT_ACCESS_TEST_ANY, DEFAULT_ACCESS_TEST_ADMIN ].join
+test "should allow access to something for anonymous" do
+  path = foo_path
+  get(path)
+  assert_response :success
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', allow_anon: true
+
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects allow_any_user' do
+    valid = [ DEFAULT_ACCESS_TEST_ANON, <<-EOC, DEFAULT_ACCESS_TEST_ADMIN ].join
+test "should allow access to something for any user" do
+  user = incline_users(:basic)
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_response :success
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', allow_any_user: true
+
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects allow_admin' do
+    valid = [ DEFAULT_ACCESS_TEST_ANON, DEFAULT_ACCESS_TEST_ANY, <<-EOC ].join
+test "should not allow access to something for admin user" do
+  user = incline_users(:admin)
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_redirected_to main_app.root_path
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', allow_admin: false
+
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects allow_groups' do
+    valid = [ DEFAULT_ACCESS_TEST_ANON, DEFAULT_ACCESS_TEST_ANY, DEFAULT_ACCESS_TEST_ADMIN, <<-EOC ].join
+test "should allow access to something for Group 1 member" do
+  user = incline_users(:basic)
+  group = Incline::AccessGroup.find_or_create_by(name: "Group 1")
+  user.groups << group
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_response :success
+end
+test "should allow access to something for Group 2 member" do
+  user = incline_users(:basic)
+  group = Incline::AccessGroup.find_or_create_by(name: "Group 2")
+  user.groups << group
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_response :success
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', allow_groups: [ 'Group 1', 'Group 2' ]
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects deny_groups' do
+    valid = [ DEFAULT_ACCESS_TEST_ANON, DEFAULT_ACCESS_TEST_ANY, DEFAULT_ACCESS_TEST_ADMIN, <<-EOC ].join
+test "should not allow access to something for Group 1 member" do
+  user = incline_users(:basic)
+  group = Incline::AccessGroup.find_or_create_by(name: "Group 1")
+  user.groups << group
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_redirected_to main_app.root_path
+end
+test "should not allow access to something for Group 2 member" do
+  user = incline_users(:basic)
+  group = Incline::AccessGroup.find_or_create_by(name: "Group 2")
+  user.groups << group
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_redirected_to main_app.root_path
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', deny_groups: [ 'Group 1', 'Group 2' ]
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects success value' do
+    valid = [ DEFAULT_ACCESS_TEST_ANON, DEFAULT_ACCESS_TEST_ANY, <<-EOC ].join
+test "should allow access to something for admin user" do
+  user = incline_users(:admin)
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_redirected_to bar_path
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', success: 'bar_path'
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects failure value' do
+    valid = [ DEFAULT_ACCESS_TEST_ANON, <<-EOC, DEFAULT_ACCESS_TEST_ADMIN ].join
+test "should not allow access to something for any user" do
+  user = incline_users(:basic)
+  log_in_as user
+  path = foo_path
+  get(path)
+  assert_redirected_to bar_path
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', failure: 'bar_path'
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects anon_failure value' do
+    valid = [ <<-EOC, DEFAULT_ACCESS_TEST_ANY, DEFAULT_ACCESS_TEST_ADMIN ].join
+test "should not allow access to something for anonymous" do
+  path = foo_path
+  get(path)
+  assert_redirected_to bar_path
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', anon_failure: 'bar_path'
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects method value' do
+    valid = <<-EOC
+test "should not allow access to something for anonymous" do
+  path = foo_path
+  delete(path)
+  assert_redirected_to incline.login_path
+end
+test "should not allow access to something for any user" do
+  user = incline_users(:basic)
+  log_in_as user
+  path = foo_path
+  delete(path)
+  assert_redirected_to main_app.root_path
+end
+test "should allow access to something for admin user" do
+  user = incline_users(:admin)
+  log_in_as user
+  path = foo_path
+  delete(path)
+  assert_redirected_to foobars_path
+end
+    EOC
+
+    code = self.class.access_tests_for :something, return_code: true, controller: 'foobar', url_helper: 'foo_path', method: 'delete'
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for guesses at url_helper correctly' do
+    original = <<-EOC
+test "should not allow access to index for anonymous" do
+  path = foobars_path
+  get(path)
+  assert_redirected_to incline.login_path
+end
+test "should not allow access to index for any user" do
+  user = incline_users(:basic)
+  log_in_as user
+  path = foobars_path
+  get(path)
+  assert_redirected_to main_app.root_path
+end
+test "should allow access to index for admin user" do
+  user = incline_users(:admin)
+  log_in_as user
+  path = foobars_path
+  get(path)
+  assert_response :success
+end
+    EOC
+
+    # index
+    code = self.class.access_tests_for :index, return_code: true, controller: 'foobar'
+    assert_equal original, code
+
+    # show
+    valid = original
+                .gsub('access to index', 'access to show')
+                .gsub('path = foobars_path', 'path = foobar_path(foobars(:one))')
+    code = self.class.access_tests_for :show, return_code: true, controller: 'foobar'
+    assert_equal valid, code
+
+    # edit
+    valid = original
+                .gsub('access to index', 'access to edit')
+                .gsub('path = foobars_path', 'path = edit_foobar_path(foobars(:one))')
+    code = self.class.access_tests_for :edit, return_code: true, controller: 'foobar'
+    assert_equal valid, code
+
+    # update
+    valid = original
+                .gsub('access to index', 'access to update')
+                .gsub('path = foobars_path', 'path = foobar_path(foobars(:one))')
+                .gsub('get(path)', 'patch(path)')
+                .gsub('assert_response :success', 'assert_redirected_to foobars_path')
+    code = self.class.access_tests_for :update, return_code: true, controller: 'foobar'
+    assert_equal valid, code
+
+    # new
+    valid = original
+                .gsub('access to index', 'access to new')
+                .gsub('path = foobars_path', 'path = new_foobar_path')
+    code = self.class.access_tests_for :new, return_code: true, controller: 'foobar'
+    assert_equal valid, code
+
+    # create
+    valid = original
+                .gsub('access to index', 'access to create')
+                .gsub('get(path)', 'post(path)')
+                .gsub('assert_response :success', 'assert_redirected_to foobars_path')
+    code = self.class.access_tests_for :create, return_code: true, controller: 'foobar'
+    assert_equal valid, code
+
+    # destroy
+    valid = original
+                .gsub('access to index', 'access to destroy')
+                .gsub('path = foobars_path', 'path = foobar_path(foobars(:one))')
+                .gsub('get(path)', 'delete(path)')
+                .gsub('assert_response :success', 'assert_redirected_to foobars_path')
+    code = self.class.access_tests_for :destroy, return_code: true, controller: 'foobar'
+    assert_equal valid, code
+
+    # index + show
+    valid = original +
+        original
+            .gsub('access to index', 'access to show')
+            .gsub('path = foobars_path', 'path = foobar_path(foobars(:one))')
+    code = self.class.access_tests_for [ :index, :show ], return_code: true, controller: 'foobar'
+    assert_equal valid, code
+
+    # the actions can be specified as an explicit array or as additional parameters.
+    # as long as the options are specified last, it will work.
+    code = self.class.access_tests_for :index, :show, return_code: true, controller: 'foobar'
+    assert_equal valid, code
+  end
+
+  test 'access_tests_for respects the fixture_helper value for guessed url_helpers' do
+    code = self.class.access_tests_for :show, return_code: true, controller: 'foobar', fixture_helper: 'foobazzes'
+    assert_equal <<-EOC, code
+test "should not allow access to show for anonymous" do
+  path = foobar_path(foobazzes(:one))
+  get(path)
+  assert_redirected_to incline.login_path
+end
+test "should not allow access to show for any user" do
+  user = incline_users(:basic)
+  log_in_as user
+  path = foobar_path(foobazzes(:one))
+  get(path)
+  assert_redirected_to main_app.root_path
+end
+test "should allow access to show for admin user" do
+  user = incline_users(:admin)
+  log_in_as user
+  path = foobar_path(foobazzes(:one))
+  get(path)
+  assert_response :success
+end
+    EOC
+  end
+
+  test 'access_tests_for respects the fixture_key value for guessed url_helpers' do
+    code = self.class.access_tests_for :show, return_code: true, controller: 'foobar', fixture_key: :forty_two
+    assert_equal <<-EOC, code
+test "should not allow access to show for anonymous" do
+  path = foobar_path(foobars(:forty_two))
+  get(path)
+  assert_redirected_to incline.login_path
+end
+test "should not allow access to show for any user" do
+  user = incline_users(:basic)
+  log_in_as user
+  path = foobar_path(foobars(:forty_two))
+  get(path)
+  assert_redirected_to main_app.root_path
+end
+test "should allow access to show for admin user" do
+  user = incline_users(:admin)
+  log_in_as user
+  path = foobar_path(foobars(:forty_two))
+  get(path)
+  assert_response :success
+end
+    EOC
+  end
+
+
+end

data/test/extensions/time_zone_converter_extensions_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class TimeZoneConverterExtensionsTest < ActiveSupport::TestCase
+
+  # The effects of the extensions should be felt in other tests, this one simply verifies that the extension has been included.
+  test 'should include TimeZoneConverter extension' do
+    assert ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.include? Incline::Extensions::TimeZoneConverter
+  end
+
+end

data/test/fixtures/incline/access_group_group_members.yml

@@ -0,0 +1 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html

data/test/fixtures/incline/access_group_user_members.yml

@@ -0,0 +1 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html

data/test/fixtures/incline/access_groups.yml

@@ -0,0 +1,13 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+
+one:
+  name: Group 1
+
+two:
+  name: Group 2
+
+three:
+  name: Group 3
+
+four:
+  name: Group 4

data/test/fixtures/incline/action_groups.yml

@@ -0,0 +1,6 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+
+test_require_group:
+  action_security: test_require_group
+  access_group: one
+

data/test/fixtures/incline/action_securities.yml

@@ -0,0 +1,18 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+one:
+  controller_name: world
+  action_name: hello
+  path: /world/hello
+  visible: true
+
+two:
+  controller_name: foo
+  action_name: bar
+  path: /foo/bar
+  visible: true
+
+test_require_group:
+  controller_name: incline/access_test
+  action_name: test_require_group
+  path: /incline/test/require_group
+  visible: true

data/test/fixtures/incline/user_login_histories.yml

@@ -0,0 +1 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html