barkest_core 1.5.3.0

data/test/integration/users_signup_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class UsersSignupTest < ActionDispatch::IntegrationTest
+
+  def setup
+    ActionMailer::Base.deliveries.clear
+  end
+
+  test 'invalid signup information' do
+    get signup_path
+    assert_no_difference 'User.count' do
+      post signup_path, user: {
+          name: '',
+          email: 'user@invalid',
+          password: 'foo',
+          password_confirmation: 'baz'
+      }
+    end
+    assert_template 'users/new'
+    assert_select 'div#error_explanation'
+  end
+
+  test 'valid signup information' do
+    get signup_path
+    assert_difference 'User.count', 1 do
+      post signup_path, user: {
+          name: 'Example User',
+          email: 'new-user@example.com',
+          password: 'password',
+          password_confirmation: 'password'
+      }
+    end
+    assert_not is_logged_in?
+    assert_equal 1, ActionMailer::Base.deliveries.size
+    user = assigns(:user)
+    assert_not user.activated?
+    token = user.activation_token
+    assert_not_nil token
+    # try logging in before activation
+    log_in_as user
+    assert_not is_logged_in?
+    # invalid activation token
+    get edit_account_activation_url('invalid token', email: user.email)
+    assert_not is_logged_in?
+    assert_not user.reload.activated?
+    # valid activation token
+    get edit_account_activation_url(token, email: user.email)
+    assert user.reload.activated?
+    follow_redirect!
+    assert_template 'users/show'
+    assert is_logged_in?
+  end
+
+end

data/test/mailers/barkest_core/contact_form_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class BarkestCore::ContactFormTest < ActionMailer::TestCase
+  def setup
+    @msg = BarkestCore::ContactMessage.new(
+        your_name: 'John Doe',
+        your_email: 'jdoe@example.com',
+        related_to: 'Other',
+        subject: 'Hello world',
+        body: 'Hello world from the contact form.',
+        remote_ip: '127.0.0.1'
+    )
+  end
+
+  test "contact" do
+    mail = BarkestCore::ContactForm.contact(@msg)
+    assert_equal @msg.full_subject, mail.subject
+
+    assert_equal [BarkestCore::ContactForm.default_recipient], mail.to, 'Recipient is wrong.'
+    assert_equal [BarkestCore::ContactForm.default_sender], mail.from, 'Sender is wrong.'
+
+    assert_match @msg.your_name, mail.body.encoded
+    assert_match @msg.your_email, mail.body.encoded
+    assert_match @msg.body, mail.body.encoded
+    assert_match @msg.remote_ip, mail.body.encoded
+  end
+
+end

data/test/mailers/barkest_core/user_mailer_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module BarkestCore
+  class UserMailerTest < ActionMailer::TestCase
+
+    def sender_address
+      BarkestCore.email_config[:default_sender]
+    end
+
+    test 'account_activation' do
+      user = users(:standard)
+      user.activation_token = User.new_token
+      mail = BarkestCore::UserMailer.account_activation(user: user)
+      assert_equal 'Account activation', mail.subject
+      assert_equal [user.email], mail.to
+      assert_equal [sender_address], mail.from
+      assert_match user.name, mail.body.encoded
+      assert_match user.activation_token, mail.body.encoded
+      assert_match CGI::escape(user.email), mail.body.encoded
+    end
+
+    test 'password_reset' do
+      user = users(:standard)
+      user.reset_token = User.new_token
+      mail = BarkestCore::UserMailer.password_reset(user: user)
+      assert_equal 'Password reset request', mail.subject
+      assert_equal [user.email], mail.to
+      assert_equal [sender_address], mail.from
+      assert_match user.reset_token, mail.body.encoded
+      assert_match CGI::escape(user.email), mail.body.encoded
+    end
+
+    test 'invalid_password_reset' do
+      email = 'sombody@example.com'
+      mail = BarkestCore::UserMailer.invalid_password_reset(email: email)
+      assert_equal 'Password reset request', mail.subject
+      assert_equal [email], mail.to
+      assert_equal [sender_address], mail.from
+      assert_match email, mail.body.encoded
+    end
+
+  end
+end

data/test/mailers/previews/barkest_core/contact_form_preview.rb

@@ -0,0 +1,17 @@
+# Preview all emails at http://localhost:3000/rails/mailers/barkest_core/contact_form
+class BarkestCore::ContactFormPreview < ActionMailer::Preview
+
+  # Preview this email at http://localhost:3000/rails/mailers/barkest_core/contact_form/contact
+  def contact
+    msg = BarkestCore::ContactMessage.new(
+        your_name: 'John Doe',
+        your_email: 'jdoe@example.com',
+        related_to: 'Other',
+        subject: 'Hello world',
+        body: 'Hello world from the contact form.',
+        remote_ip: '127.0.0.1'
+    )
+    BarkestCore::ContactForm.contact msg
+  end
+
+end

data/test/mailers/previews/barkest_core/user_mailer_preview.rb

@@ -0,0 +1,26 @@
+module BarkestCore
+  # Preview all emails at http://localhost:3000/rails/mailers/barkest_core/user_mailer
+  class UserMailerPreview < ActionMailer::Preview
+
+    # Preview this email at http://localhost:3000/rails/mailers/barkest_core/user_mailer/account_activation
+    def account_activation
+      user = User.first
+      user.activation_token = User.new_token
+      UserMailer.account_activation user: user
+    end
+
+    # Preview this email at http://localhost:3000/rails/mailers/barkest_core/user_mailer/password_reset
+    def password_reset
+      user = User.first
+      user.reset_token = User.new_token
+      UserMailer.password_reset user: user
+    end
+
+    # Preview this email at http://localhost:3000/rails/mailers/barkest_core/user_mailer/invalid_password_reset
+    def invalid_password_reset
+      email = 'nobody@example.com'
+      UserMailer.invalid_password_reset email: email
+    end
+
+  end
+end

data/test/models/access_group_group_member_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class AccessGroupGroupMemberTest < ActiveSupport::TestCase
+
+  def setup
+    @group1 = access_groups(:one)
+    @group2 = access_groups(:two)
+    @group3 = access_groups(:three)
+    @item = 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 'should require unique member_id per group_id' do
+    assert_uniqueness @item, :member_id, false, group_id: @group3.id
+  end
+
+end

data/test/models/access_group_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+class AccessGroupTest < ActiveSupport::TestCase
+
+  def setup
+    @group = AccessGroup.new(name: 'Group X')
+    @group1 = 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.members << @group1
+
+    assert @group.valid?
+
+    @group.save!
+
+    # group-x should have one member and group-1 should belong to one group.
+    assert_equal 1, @group.members(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.members.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
+
+  test 'should allow ldap group assignment' do
+
+    # group must be saved first.
+    @group.save!
+    @group.reload
+
+    assert @group.valid?
+
+    assert @group.ldap_group_list.blank?
+
+    other_ldap_count = LdapAccessGroup.count
+
+    list1 = [ 'GROUP A', 'GROUP B', 'GROUP C', 'GROUP D' ]
+    list2 = [ 'GROUP E', 'GROUP F', 'GROUP G' ]
+
+    [list1, list2].each do |list|
+
+      assert @group.valid?
+
+      # Assign to the list.
+      @group.ldap_group_list = list.join("\n")
+      assert @group.save
+
+      # the list should no longer be blank.
+      assert_not @group.ldap_group_list.blank?
+
+      # and the ldap_groups count should match the list count.
+      assert_equal list.length, @group.ldap_groups.count
+      assert_equal other_ldap_count + list.count, LdapAccessGroup.count
+
+      # first pass to ensure all the groups we provided exist.
+      list.each do |name|
+        assert_equal 1, @group.ldap_groups.where(name: name).count, "Missing '#{name}' LDAP group."
+      end
+
+      # second pass to ensure all the groups in the list were provided by us.
+      @group.ldap_groups.each do |group|
+        assert list.include?(group.name), "Extra '#{group.name}' LDAP group."
+      end
+
+    end
+
+    # reset the list.
+    @group.ldap_group_list = nil
+    assert @group.ldap_group_list.blank?
+
+    # assignment of arrays should also work.
+    @group.ldap_group_list = []
+    assert @group.ldap_group_list.blank?
+
+    @group.ldap_group_list = list1
+    assert_not @group.ldap_group_list.blank?
+    assert_equal list1.length, @group.ldap_groups.count
+
+  end
+
+end

data/test/models/access_group_user_member_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class AccessGroupUserMemberTest < ActiveSupport::TestCase
+
+  def setup
+    @group1 = access_groups(:one)
+    @group2 = access_groups(:two)
+    @user5 = users(:user_5)
+    @item = AccessGroupUserMember.new(group_id: @group1.id, member_id: @user5.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 'should require unique member_id per group_id' do
+    assert_uniqueness @item, :member_id, false, group_id: @group2.id
+  end
+  
+end

data/test/models/barkest_core/auth_config_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module BarkestCore
+  class AuthConfigTest < ActiveSupport::TestCase
+    def setup
+      @item = BarkestCore::AuthConfig.new(enable_db_auth: true)
+      @item2 = BarkestCore::AuthConfig.new(
+          enable_ldap_auth: true,
+          ldap_host: 'localhost',
+          ldap_port: 389,
+          ldap_base_dn: 'DC=localhost',
+          ldap_browse_user: 'xyz',
+          ldap_browse_password: 'abc',
+          ldap_system_admin_groups: 'none'
+      )
+
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+      assert @item2.valid?
+    end
+
+    test 'should require enable_x_auth' do
+      @item.enable_db_auth = false
+      assert_not @item.valid?
+      @item2.enable_ldap_auth = false
+      assert_not @item.valid?
+    end
+
+    test 'should require ldap_host' do
+      assert_required @item2, :ldap_host
+    end
+
+    test 'should require ldap_port' do
+      assert_required @item2, :ldap_port
+    end
+
+    test 'should require ldap_base_dn' do
+      assert_required @item2, :ldap_base_dn
+    end
+
+    test 'should require ldap_browse_user' do
+      assert_required @item2, :ldap_browse_user
+    end
+
+    test 'should require ldap_browse_password' do
+      assert_required @item2, :ldap_browse_password
+    end
+
+    test 'should require ldap_system_admin_groups' do
+      assert_required @item2, :ldap_system_admin_groups
+    end
+
+
+  end
+end

data/test/models/barkest_core/bool_parser_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module BarkestCore
+  class BoolParserTest < ActiveSupport::TestCase
+
+    test 'should parse true values' do
+      %w(TRUE true True YES yes Yes ON on On 1 -1 T t Y y).each do |val|
+        assert BarkestCore::BooleanParser.parse_for_boolean_column(val), "#{val.inspect} should be true"
+        assert_equal "1", BarkestCore::BooleanParser.parse_for_boolean_filter(val), "#{val.inspect} should be true"
+      end
+    end
+
+    test 'should parse false values' do
+      %w(FALSE false False NO no No OFF off Off 0 F f N n).each do |val|
+        assert_not BarkestCore::BooleanParser.parse_for_boolean_column(val), "#{val.inspect} should be false"
+        assert_equal "0", BarkestCore::BooleanParser.parse_for_boolean_filter(val), "#{val.inspect} should be false"
+      end
+    end
+
+    test 'should parse nil values' do
+      [ nil, '', '   ' ].each do |val|
+        assert_nil BarkestCore::BooleanParser.parse_for_boolean_column(val), "#{val.inspect} should be nil"
+        assert_equal "NULL", BarkestCore::BooleanParser.parse_for_boolean_filter(val), "#{val.inspect} should be nil"
+      end
+    end
+
+  end
+end

data/test/models/barkest_core/contact_message_test.rb

@@ -0,0 +1,61 @@
+module BarkestCore
+  class ContactMessageTest < ActiveSupport::TestCase
+
+    def setup
+      @item = BarkestCore::ContactMessage.new(
+          your_name: 'John Doe',
+          your_email: 'jdoe@example.com',
+          related_to: 'Nothing Important',
+          body: 'This is my message.',
+      )
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require subject for other' do
+      # if related_to == 'other' then subject should now be required.
+      @item.related_to = 'Other'
+      assert_not @item.valid?
+      @item.subject = 'Nothing Important'
+      assert @item.valid?
+      assert_required @item, :subject
+    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 body' do
+      assert_required @item, :body
+    end
+
+    test 'email validation should accept valid addresses' do
+      valid = %w[user@example.com USER@foo.COM A_US-ER@foo.bar.org first.last@foo.jp alice+bob@bax.cn]
+
+      valid.each do |address|
+        @item.your_email = address
+        assert @item.valid?, "#{address.inspect} should be valid"
+      end
+    end
+
+    test 'email validation should reject invalid addresses' do
+      invalid = %w[user@example,com user_at_foo.org user.name@example. foo@bar_baz.com foo@bar+baz.com @example.com user@ user user@..com user@example..com]
+      invalid.each do |address|
+        @item.your_email = address
+        assert_not @item.valid?, "#{address.inspect} should be invalid"
+      end
+    end
+
+
+  end
+end