barkest_core 1.5.3.0

data/test/models/barkest_core/ms_sql_function_test.rb

@@ -0,0 +1,131 @@
+require 'test_helper'
+module BarkestCore
+  class MsSqlFunctionTest < ActiveSupport::TestCase
+
+    # There is a weird glitch? in ActiveRecord.
+    # If I establish a connection here then ALL ActiveRecord transactions seem to hit up the
+    # SQL server for at least a "reset!" call.  On a high latency (VPN) connection, this is
+    # very noticeable and causes the entire test routine to take several minutes.
+    #
+    # Instead we establish the connection before our tests here and remove the connection
+    # immediately after.  That seems to keep the test suite running quickly.
+    #
+    # Hopefully this is not an issue that occurs during production, I have not noticed it in
+    # development yet, only testing.
+    class MyTestFunctionParentTable < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    class MyTestFunction < ::BarkestCore::MsSqlFunction
+
+    end
+
+    MY_TEST_FUNCTION_NAME = 'zz_barkest_core_test_function'
+
+    MY_TEST_FUNCTION_DEFINITION = <<-EOSQL
+CREATE FUNCTION #{MY_TEST_FUNCTION_NAME}(
+  @alpha INTEGER,
+  @bravo VARCHAR(100),
+  @charlie DATETIME
+) RETURNS TABLE AS RETURN
+SELECT
+  LEN(ISNULL(@bravo,'')) AS [bravo_len],
+  LEN(ISNULL(@bravo,'')) * ISNULL(@alpha,0) AS [alpha_bravo],
+  CONVERT(FLOAT, LEN(ISNULL(@bravo, ''))) / 100.0 AS [bravo_len_pct],
+  CONVERT(BIT, CASE
+    WHEN @alpha > 25 THEN 1
+    ELSE 0
+  END) AS [alpha_gt_25],
+  ISNULL(@alpha,0) AS [alpha],
+  ISNULL(@bravo,'') AS [bravo],
+  ISNULL(@charlie, GETDATE()) AS [charlie]
+    EOSQL
+
+    MY_TEST_FUNCTION_PARAMS = {
+        :alpha=>{:type=>:integer, :data_type=>'integer'},
+        :bravo=>{:type=>:string, :data_type=>'varchar(100)'},
+        :charlie=>{:type=>:datetime, :data_type=>'datetime'}
+    }
+
+    MY_TEST_FUNCTION_COLUMNS = [
+        {:name=>'bravo_len',      :key=>:bravo_len,     :data_type=>'int',            :type=>:integer},
+        {:name=>'alpha_bravo',    :key=>:alpha_bravo,   :data_type=>'int',            :type=>:integer},
+        {:name=>'bravo_len_pct',  :key=>:bravo_len_pct, :data_type=>'float',          :type=>:float},
+        {:name=>'alpha_gt_25',    :key=>:alpha_gt_25,   :data_type=>'bit',            :type=>:boolean},
+        {:name=>'alpha',          :key=>:alpha,         :data_type=>'int',            :type=>:integer},
+        {:name=>'bravo',          :key=>:bravo,         :data_type=>'varchar(100)',   :type=>:string,     :length=>100},
+        {:name=>'charlie',        :key=>:charlie,       :data_type=>'datetime',       :type=>:datetime}
+    ]
+
+    test 'ms sql function parsing' do
+      begin
+        MyTestFunctionParentTable.establish_connection BarkestCore.db_config(:ms_sql_test)
+        # set the connection handler
+        MyTestFunction.use_connection MyTestFunctionParentTable
+        # create the UDF
+        MyTestFunction.connection.execute MY_TEST_FUNCTION_DEFINITION
+      rescue Exception => e
+        MyTestFunctionParentTable.remove_connection
+        skip "Invalid test MSSQL configuration: #{e.message}"
+      end
+
+      begin
+        # parse the function
+        MyTestFunction.function_name = MY_TEST_FUNCTION_NAME
+
+        # params should match up.
+        MyTestFunction.parameters.each do |param_key, param_attrib|
+          valid = MY_TEST_FUNCTION_PARAMS[param_key]
+          assert_not_nil valid, "Function has extra #{param_key} parameter."
+          assert_equal valid[:type], param_attrib[:type], "Parameter #{param_key} has the wrong type."
+          assert_equal valid[:data_type], param_attrib[:data_type], "Parameter #{param_key} has the wrong data_type."
+        end
+
+        MY_TEST_FUNCTION_PARAMS.each do |param_key, _|
+          assert_not_nil MyTestFunction.parameters[param_key], "Function is missing #{param_key} parameter."
+        end
+
+        # columns should match up.
+        MyTestFunction.columns.each do |attribs|
+          valid = MY_TEST_FUNCTION_COLUMNS.find{|v| v[:name] == attribs[:name]}
+          assert_not_nil valid, "Function has extra #{attribs[:name]} column."
+          assert_equal valid[:key], attribs[:key], "Column #{attribs[:name]} has the wrong key."
+          assert_equal valid[:data_type], attribs[:data_type], "Column #{attribs[:name]} has the wrong data type."
+          assert_equal valid[:type], attribs[:type], "Column #{attribs[:name]} has the wrong type."
+          if valid[:length]
+            assert_equal valid[:length], attribs[:length], "Column #{attribs[:name]} has the wrong length."
+          end
+        end
+
+        MY_TEST_FUNCTION_COLUMNS.each do |valid|
+          col = MyTestFunction.columns.find{|v| v[:name] == valid[:name]}
+          assert_not_nil col, "Function is missing #{valid[:name]} column."
+        end
+
+        # and then tests.
+        [
+            [10, 'Hello', 5.days.ago],
+            [61, 'Some test text to test with!', Time.zone.now + 5.days]
+        ].each do |(alpha, bravo, charlie)|
+
+          result = MyTestFunction.select(alpha: alpha, bravo: bravo, charlie: charlie)
+
+          assert_not_nil result
+          assert_equal 1, result.count
+          result = result.first
+
+          assert_equal bravo.length, result.bravo_len
+          assert_equal alpha * bravo.length, result.alpha_bravo
+          assert_equal bravo.length * 0.01, result.bravo_len_pct
+          assert_equal alpha > 25, result.alpha_gt_25?
+        end
+
+      ensure
+        MyTestFunction.connection.execute "DROP FUNCTION #{MY_TEST_FUNCTION_NAME}"
+        MyTestFunctionParentTable.remove_connection
+      end
+    end
+
+
+  end
+end

data/test/models/barkest_core/number_parser_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module BarkestCore
+  class NumberParserTest < ActiveSupport::TestCase
+
+    test 'should parse valid numbers' do
+      {
+          '0' => 0.0, '123' => 123.0, '123.4' => 123.4, '12345' => 12345.0, '12,345' => 12345.0, '12,345.678' => 12345.678, '1,234,567' => 1234567.0,
+          '-123' => -123.0, '-123.4' => -123.4, '-12345' => -12345.0, '-12,345' => -12345.0, '-12,345.678' => -12345.678, '-1,234,567' => -1234567.0,
+          '+123' => 123.0, '+123.4' => 123.4, '+12345' => 12345.0, '+12,345' => 12345.0, '+12,345.678' => 12345.678, '+1,234,567' => 1234567.0,
+      }.each do |k,v|
+        assert_equal v, BarkestCore::NumberParser.parse_for_float_column(k), "#{k} should be a valid float"
+        assert_equal v.to_i, BarkestCore::NumberParser.parse_for_int_column(k), "#{k} should be a valid int"
+        assert_equal v, BarkestCore::NumberParser.parse_for_float_filter(k).to_f, "#{k} should be a valid float filter"
+        assert_equal v.to_i, BarkestCore::NumberParser.parse_for_int_filter(k).to_i, "#{k} should be a valid int filter"
+      end
+    end
+
+    test 'should parse nil values' do
+      [ nil, '', '  ' ].each do |v|
+        assert_nil BarkestCore::NumberParser.parse_for_float_column(v), "#{v.inspect} should not be a valid float"
+        assert_nil BarkestCore::NumberParser.parse_for_int_column(v), "#{v.inspect} should not be a valid int"
+        assert_equal "NULL", BarkestCore::NumberParser.parse_for_float_filter(v), "#{v.inspect} should be a NULL float filter"
+        assert_equal "NULL", BarkestCore::NumberParser.parse_for_int_filter(v), "#{v.inspect} should be a NULL int filter"
+      end
+    end
+
+  end
+end

data/test/models/barkest_core/self_update_config_test.rb

@@ -0,0 +1,29 @@
+module BarkestCore
+  class SelfUpdateConfigTest < ActiveSupport::TestCase
+
+    def setup
+      @item = BarkestCore::SelfUpdateConfig.new(
+          host: '127.0.0.1',
+          user: 'somebody',
+          password: 'secret',
+      )
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require host' do
+      assert_required @item, :host
+    end
+
+    test 'should require user' do
+      assert_required @item, :user
+    end
+
+    test 'should require password' do
+      assert_required @item, :password
+    end
+
+  end
+end

data/test/models/barkest_core/user_alert_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+module BarkestCore
+  class UserAlertTest < ActiveSupport::TestCase
+
+    def setup
+      @item = BarkestCore::UserAlert.new(message: 'Something you need to know.')
+    end
+
+    test 'should be valid' do
+      assert @item.valid?
+    end
+
+    test 'should require message' do
+      assert_required @item, :message
+    end
+
+
+  end
+end

data/test/models/barkest_core/user_manager_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+module BarkestCore
+  class UserManagerTest < ActiveSupport::TestCase
+
+    def setup
+      @user = users(:standard)
+      @cfg = BarkestCore.auth_config
+      @db_only = BarkestCore::UserManager.new(@cfg.merge({enable_ldap_auth: false, enable_db_auth: true}))
+      @ldap_only = @cfg[:enable_ldap_auth] ? BarkestCore::UserManager.new(@cfg.merge({enable_db_auth: false})) : nil
+    end
+
+    test 'should be able to authenticate with default admin for db-only' do
+      assert @db_only.authenticate( @user.email, 'password', '0.0.0.0' )
+    end
+
+    test 'should not be able to authenticate with default admin for ldap-only' do
+      skip 'LDAP not configured.' unless @ldap_only
+      assert_not @ldap_only.authenticate( 'admin@barkerest.com', 'Password1', '0.0.0.0' )
+    end
+
+    test 'should be able to login with test credentials for ldap-only' do
+      skip 'LDAP not configured.' unless @ldap_only
+      skip 'Missing :ldap_test_email or :ldap_ldap_password configuration.' if @cfg[:ldap_test_email].blank? || @cfg[:ldap_test_password].blank?
+      assert @ldap_only.authenticate(@cfg[:ldap_test_email], @cfg[:ldap_test_password], '0.0.0.0' )
+    end
+
+    test 'should not be able to login with test credentials for db-only' do
+      skip 'LDAP not configured.' unless @ldap_only
+      skip 'Missing :ldap_test_email or :ldap_test_password configuration.' if @cfg[:ldap_test_email].blank? || @cfg[:ldap_test_password].blank?
+      assert_not @db_only.authenticate(@cfg[:ldap_test_email], @cfg[:ldap_test_password], '0.0.0.0' )
+    end
+
+  end
+end

data/test/models/barkest_core/work_path_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module BarkestCore
+  class WorkPathTest < ActiveSupport::TestCase
+
+    test 'should get a valid location' do
+      assert_not_nil BarkestCore::WorkPath.location
+      assert Dir.exist?(BarkestCore::WorkPath.location)
+    end
+
+    test 'should get valid path for temp file' do
+      path = BarkestCore::WorkPath.path_for('test.file')
+      assert_not_nil path
+
+      # we should be able to write and delete the test file successfully.
+      # ironically, this is the same code used in the WorkPath class
+      # to verify the path is usable, which makes this redundant, but
+      # testing is supposed to be thorough, so I'm leaving it in place.
+      File.write path, 'This is a test.'
+      File.delete path
+
+    end
+
+
+  end
+end

data/test/models/disable_user_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class DisableUserTest < ActiveSupport::TestCase
+
+  def setup
+    @user = users(:user_5)
+    @item = DisableUser.new(user: @user, reason: 'Some valid reason')
+  end
+
+  test 'should be valid' do
+    assert @item.valid?
+  end
+
+  test 'should require reason' do
+    assert_required @item, :reason
+  end
+
+  test 'should require user' do
+    assert_required @item, :user
+  end
+
+  test 'user must be enabled' do
+    @user.enabled = false
+    assert_not @item.valid?
+  end
+
+end

data/test/models/generic_time_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class GenericTimeTest < ActiveSupport::TestCase
+
+  test 'should handle time objects' do
+    [
+        Time.utc(2016, 12, 19, 15, 45),
+        Time.new(2016, 12, 19, 15, 45),
+        Time.new,
+        Time.zone.now,
+        Time.zone.local(2016, 12, 19, 15, 45),
+        Date.today,
+    ].each do |item|
+      assert_equal item.to_time.utc, Time.utc_parse(item), "Item #{item.inspect} does not parse to #{item.to_time.utc.inspect}."
+    end
+  end
+
+  test 'should handle ISO formatted strings' do
+    {
+        '2016-12-19'              => Time.utc(2016, 12, 19),
+        '2016-12-19 15:45'        => Time.utc(2016, 12, 19, 15, 45),
+        '2016-12-19 15:45:15'     => Time.utc(2016, 12, 19, 15, 45, 15),
+        '2016-12-19 15:45 -500'   => Time.utc(2016, 12, 19, 20, 45),
+        '2016-12-19 15:45 -0500'  => Time.utc(2016, 12, 19, 20, 45),
+        '2016-12-19 15:45 -05:00' => Time.utc(2016, 12, 19, 20, 45),
+        '2016-12-19 20:45 +500'   => Time.utc(2016, 12, 19, 15, 45),
+        '2016-12-19 20:45 +0500'  => Time.utc(2016, 12, 19, 15, 45),
+        '2016-12-19 20:45 +05:00' => Time.utc(2016, 12, 19, 15, 45),
+        '2016-12-19 20:45 UTC'    => Time.utc(2016, 12, 19, 20, 45),
+    }.each do |key, val|
+      assert_equal val, Time.utc_parse(key), "Item #{key} does not parse to #{val.inspect}."
+    end
+  end
+
+  test 'should handle other select formats' do
+    {
+        '16-12-19'                => Time.utc(2016, 12, 19),
+        '12/19/16'                => Time.utc(2016, 12, 19),
+        '12/19/2016'              => Time.utc(2016, 12, 19),
+        '12/19'                   => Time.utc(Time.now.utc.year, 12, 19),
+        '1219'                    => Time.utc(Time.now.utc.year, 12, 19),
+        '121916'                  => Time.utc(2016, 12, 19),
+        '12192016'                => Time.utc(2016, 12, 19),
+        '12/19/16 15:45'          => Time.utc(2016, 12, 19, 15, 45),
+        '12/19/16 3:45pm'         => Time.utc(2016, 12, 19, 15, 45),
+        '12/19/16 3:45 pm'        => Time.utc(2016, 12, 19, 15, 45),
+        '12/19/16 3:45 pm -500'   => Time.utc(2016, 12, 19, 20, 45),
+        '12/19/16 12 am'          => Time.utc(2016, 12, 19, 0, 0),
+        '12/19/16 12 pm'          => Time.utc(2016, 12, 19, 12, 0),
+        '12/19/16 3 am'           => Time.utc(2016, 12, 19, 3, 0),
+        '12/19/16 3 pm'           => Time.utc(2016, 12, 19, 15, 0),
+        '15:45:30'                => Time.utc(1900, 1, 1, 15, 45, 30),
+        '15:45:30 -500'           => Time.utc(1900, 1, 1, 20, 45, 30),
+        '12'                      => Time.utc(1900, 1, 1, 12, 0),
+        '12am'                    => Time.utc(1900, 1, 1, 0, 0),
+        '12 am'                   => Time.utc(1900, 1, 1, 0, 0),
+        '12PM'                    => Time.utc(1900, 1, 1, 12, 0),
+        '12 PM -500'              => Time.utc(1900, 1, 1, 17, 0),
+        '3:45 pm'                 => Time.utc(1900, 1, 1, 15, 45),
+        '3:45 pm -05:00'          => Time.utc(1900, 1, 1, 20, 45),
+    }.each do |key, val|
+      assert_equal val, Time.utc_parse(key), "Item #{key} does not parse to #{val.inspect}."
+    end
+  end
+
+end

data/test/models/ldap_access_group_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class LdapAccessGroupTest < ActiveSupport::TestCase
+  def setup
+    @item = LdapAccessGroup.new(
+        group: access_groups(:two),
+        name: 'Ldap Group 2'
+    )
+  end
+
+  test 'should be valid' do
+    assert @item.valid?
+  end
+
+  test 'should require group' do
+    assert_required @item, :group
+  end
+
+  test 'should require name' do
+    assert_required @item, :name
+  end
+
+  test 'name should not be too long' do
+    assert_max_length @item, :name, 200
+  end
+
+  test 'name should be unique' do
+    assert_uniqueness @item, :name, :group => access_groups(:three)
+  end
+
+end

data/test/models/pdf_table_builder_test.rb

@@ -0,0 +1,6 @@
+require 'test_helper'
+
+class PdfTableBuilderTest < ActiveSupport::TestCase
+  # I don't even know where to start here.
+  # If any bugs pop up, obviously we'll test for them here, but I don't know of any so ...
+end

data/test/models/system_config_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class SystemConfigTest < ActiveSupport::TestCase
+
+  TEST_VALUES = [
+      'world',
+      :world,
+      1234,
+      56.789,
+      true,
+      false,
+      [ 1, 2, 3 ],
+      {a: 1, b: 2, c: 3},
+      Time.now
+  ]
+
+  def setup
+    @item = SystemConfig.new(key: 'hello')
+  end
+
+  test 'should be valid' do
+    assert @item.valid?
+  end
+
+  test 'should allow setting value to various types' do
+    TEST_VALUES.each do |test_value|
+      @item.value = test_value
+      @item.save!
+      assert_equal test_value, @item.value
+    end
+  end
+
+  test 'should require key' do
+    assert_required @item, :key
+    assert_not SystemConfig.set('', '')
+  end
+
+  test 'key should not be too long' do
+    assert_max_length @item, :key, 128
+  end
+
+  test 'key should be unique' do
+    assert_uniqueness @item, :key
+  end
+
+  test 'get and set should support encryption' do
+    TEST_VALUES.each do |test_value|
+      SystemConfig.set 'abc', test_value, true
+      test = SystemConfig.find_by(key: 'abc')
+
+      assert_not_nil test
+
+      assert_not_equal test_value, test.value
+      assert_equal test_value, SystemConfig.get('abc')
+
+      assert test.value.is_a?(Hash)
+      assert test.value.keys.include?(:encrypted_value)
+    end
+  end
+
+  test 'get and set methods should work' do
+    TEST_VALUES.each do |test_value|
+      SystemConfig.set 'abc', test_value
+      SystemConfig.set 'Xyz', test_value
+      assert_equal test_value, SystemConfig.get('abc')
+      assert_equal test_value, SystemConfig.get('xyz')
+      assert_equal test_value, SystemConfig.get('ABC')
+      assert_equal test_value, SystemConfig.get('XYZ')
+    end
+    SystemConfig.set 'abc', nil
+    SystemConfig.set 'Xyz', nil
+    assert_nil SystemConfig.get('abc')
+    assert_nil SystemConfig.get('xyz')
+    assert_nil SystemConfig.get('ABC')
+    assert_nil SystemConfig.get('XYZ')
+  end
+
+end