terrier-engine 4.67.10 → 4.67.13

package/test/test_helper.rb

@@ -1,19 +0,0 @@
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
-
-require_relative "../test/dummy/config/environment"
-ActiveRecord::Migrator.migrations_paths = [File.expand_path("../test/dummy/db/migrate", __dir__)]
-require "rails/test_help"
-
-# Filter out Minitest backtrace while allowing backtrace from other libraries
-# to be shown.
-Minitest.backtrace_filter = Minitest::BacktraceFilter.new
-
-
-# Load fixtures from the engine
-if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
-  ActiveSupport::TestCase.fixture_paths = [File.expand_path("fixtures", __dir__)]
-  ActionDispatch::IntegrationTest.fixture_paths = ActiveSupport::TestCase.fixture_paths
-  ActiveSupport::TestCase.file_fixture_path = ActiveSupport::TestCase.fixture_paths.first + "/files"
-  ActiveSupport::TestCase.fixtures :all
-end

package/test/unit/date_period_test.rb

@@ -1,111 +0,0 @@
-require 'test_helper'
-
-class DatePeriodTest < ActiveSupport::TestCase
-
-  test 'parse year' do
-    p = DatePeriod.parse '2022'
-    assert_equal '2022-01-01', p.start_date.to_s
-    assert_equal '2023-01-01', p.end_date.to_s
-    assert_equal '2022', p.to_s
-    assert_equal '2022', p.display_name
-  end
-
-  test 'parse year range' do
-    p = DatePeriod.parse '2022:2023'
-    assert_equal '2022-01-01', p.start_date.to_s
-    assert_equal '2024-01-01', p.end_date.to_s
-    assert_equal '2022:2023', p.to_s
-    assert_equal '2022-2023', p.display_name
-  end
-
-  test 'parse month' do
-    p = DatePeriod.parse '2022-10'
-    assert_equal '2022-10-01', p.start_date.to_s
-    assert_equal '2022-11-01', p.end_date.to_s
-    assert_equal '2022-10', p.to_s
-    assert_equal 'October 2022', p.display_name
-  end
-
-  test 'serialize last n' do
-    p = DatePeriod.last_30 '2022-11-09'
-    assert_equal '2022-10-10:2022-11-09', p.to_s
-    assert_equal '10/10/22 - 11/09/22', p.display_name
-    p = DatePeriod.last_7 '2022-11-09'
-    assert_equal '2022-11-02:2022-11-09', p.to_s
-    assert_equal '11/02/22 - 11/09/22', p.display_name
-  end
-
-  test 'parse day' do
-    p = DatePeriod.parse '2022-10-13'
-    assert_equal '2022-10-13', p.start_date.to_s
-    assert_equal '2022-10-14', p.end_date.to_s
-    assert_equal '2022-10-13', p.to_s
-    assert_equal '10/13/22', p.display_name
-  end
-
-  test 'parse date range' do
-    p = DatePeriod.parse '2022-10-13:2022-10-23'
-    assert_equal '2022-10-13', p.start_date.to_s
-    assert_equal '2022-10-23', p.end_date.to_s
-    assert_equal '2022-10-13:2022-10-22', p.to_s
-    assert_equal '10/13/22 - 10/22/22', p.display_name
-  end
-
-  test 'parse literal range hash' do
-    range = { min: '2023-05-01', max: '2023-06-01' }
-    p = DatePeriod.parse range
-    assert_equal range[:min], p.start_date.to_s
-    assert_equal range[:max], p.end_date.to_s
-  end
-
-  test 'materialize virtual range hash' do
-    today = '2023-05-12'
-
-    # days
-    assert_equal today.to_s, DatePeriod.parse({ period: 'day' }, today).to_s
-    assert_equal "2023-05-11", DatePeriod.parse({ period: 'day', relative: -1 }, today).to_s
-    assert_equal "2023-05-13", DatePeriod.parse({ period: 'day', relative: 1 }, today).to_s
-
-    # weeks
-    assert_equal "2023-05-07:2023-05-13", DatePeriod.parse({ period: 'week' }, today).to_s
-    assert_equal "2023-04-30:2023-05-06", DatePeriod.parse({ period: 'week', relative: -1 }, today).to_s
-    assert_equal "2023-05-14:2023-05-20", DatePeriod.parse({ period: 'week', relative: 1 }, today).to_s
-
-    # months
-    assert_equal "2023-05", DatePeriod.parse({ period: 'month' }, today).to_s
-    assert_equal "2023-04", DatePeriod.parse({ period: 'month', relative: -1 }, today).to_s
-    assert_equal "2023-06", DatePeriod.parse({ period: 'month', relative: 1 }, today).to_s
-
-    # years
-    assert_equal "2023", DatePeriod.parse({ period: 'year' }, today).to_s
-    assert_equal "2022", DatePeriod.parse({ period: 'year', relative: -1 }, today).to_s
-    assert_equal "2024", DatePeriod.parse({ period: 'year', relative: 1 }, today).to_s
-  end
-
-  test 'each' do
-    period = DatePeriod.parse '2022-10-01:2022-11-15'
-
-    # months
-    months = period.each 1.month do |mp|
-      mp
-    end
-    assert_equal 2, months.count
-    assert_equal '2022-11-15', months.last.end_date.to_s
-
-    # weeks
-    weeks = period.each 1.week do |wp|
-      wp
-    end
-    assert_equal 7, weeks.count
-    assert_equal '2022-11-15', weeks.last.end_date.to_s
-
-    # days
-    days = period.each 1.day do |dp|
-      dp
-    end
-    assert_equal 45, days.count
-    assert_equal days.first.end_date, days.first.start_date + 1.day
-    assert_equal '2022-11-15', days.last.end_date.to_s
-  end
-
-end

package/test/unit/loggable_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-require 'spreadsheet/workbook'
-
-require 'test_helper'
-
-class LoggableTest < ActiveSupport::TestCase
-  class DummyClass
-    include Loggable
-  end
-
-  setup do
-    @dummy_instance = DummyClass.new
-    @test_logger = Logger.new(STDOUT)
-    @dummy_instance.wrap_logger(@test_logger)
-    @dummy_instance.get_logger.level = 'debug'  # Set log level to 'debug'
-  end
-
-  test "should log messages correctly" do
-    assert_nothing_raised do
-      @dummy_instance.info("Info message")
-      @dummy_instance.success("Success message")
-      @dummy_instance.debug("Debug message")
-      @dummy_instance.warn("Warning message")
-      @dummy_instance.error(StandardError.new("Error message"))
-    end
-  end
-
-  test "should call the set log callback" do
-    callback_called = false
-
-    @dummy_instance.set_log_callback do |level, message, *args|
-      callback_called = true
-    end
-
-    @dummy_instance.info("Info message with callback")
-
-    assert callback_called, "Callback was not called"
-  end
-
-  test "should benchmark correctly" do
-    elapsed_time = @dummy_instance.bench("Test Block") do
-      # Some code to benchmark
-      t = Time.now
-      sleep(0.1)
-      dt = Time.now - t
-      dt
-    end
-
-    assert elapsed_time >= 0.1, "Benchmarking did not measure elapsed time correctly"
-  end
-end

package/test/unit/query_engine_test.rb

@@ -1,138 +0,0 @@
-require 'test_helper'
-require 'terrier/data_dive'
-require_relative '../data/test_dive'
-
-class QueryEngineTest < ActiveSupport::TestCase
-
-  def setup
-    @dive = TestDive.get
-  end
-
-  test 'order_details' do
-    query = TestDive.order_details
-    engine = DataDive::QueryEngine.new(query)
-    builder = engine.to_sql_builder
-
-    # selects
-    assert_equal ['work_order.id as "id"',
-                  'work_order.time as "Order Time"',
-                  'work_order.notes as "Order Notes"',
-                  'work_order.price as "Order Price"',
-                  'work_order.status as "status"',
-                  'location.number as "location_number"',
-                  'location.display_name as "location_name"',
-                  'created_by.email as "Created By E-Mail"',
-                  'u.first_name as "First Name"',
-                  'u.last_name as "Last Name"',
-                  'u.email as "Tech E-Mail"',
-                  'target.name as "Target"'],
-                 builder.selects
-
-    # filters
-    start_date = Date.today.beginning_of_year
-    end_date = start_date + 1.year
-    assert_equal ["work_order.time >= '#{start_date}'",
-                  "work_order.time < '#{end_date}'",
-                  "work_order.created_at < '#{start_date}'",
-                  "work_order.status in ('active','complete')",
-                  "date_part('month', time) = 11",
-                  "location.zip <> '55122'", "target.name = 'Rodents'"],
-                 builder.clauses
-
-    # order by
-    assert_equal ['"location_id" asc', '"Order Time" desc'], builder.order_bys
-  end
-
-  test "order_summary" do
-    query = TestDive.order_summary
-    engine = DataDive::QueryEngine.new(query)
-    builder = engine.to_sql_builder
-
-    assert_equal %w[date_trunc('month',work_order.time) work_order.status location.id u.id], builder.group_bys
-
-    # ensure the select statements are in the correct order
-    # which is the query's "columns" order followed by the natural order of the rest of the columns in the selects
-    selects = [
-      'location.number as "location_number"', 'work_order.status as "status"', 'to_char(date_trunc(\'month\',work_order.time),\'YYYY-MM\') as "month"', 'count(work_order.id) as "count"', 'u.first_name as "user_name"', # these are in "columns"
-      'max(time) as "max_time"', # this is a raw select
-      'location.id as "id"', 'u.id as "id"' # these two aren't in "columns"
-    ]
-    assert_equal selects, builder.selects
-  end
-
-  test "filter params" do
-    query = TestDive.order_summary
-    engine = DataDive::QueryEngine.new(query)
-
-    # show that we can override filter values explicitly through the params
-    builder = engine.to_sql_builder({'date_range_1' => '2022'})
-    assert_includes builder.clauses, "work_order.time >= '2022-01-01'"
-    assert_includes builder.clauses, "work_order.time < '2023-01-01'"
-
-    # explicit date ranges have an explicit max, so this is equivalent to a '2022-04-01'
-    builder = engine.to_sql_builder({ 'date_range_1' => '2022-04-01:2022-04-02' })
-    assert_includes builder.clauses, "work_order.time >= '2022-04-01'"
-    assert_includes builder.clauses, "work_order.time < '2022-04-02'"
-
-    # present operator
-    query = TestDive.employees
-    engine = DataDive::QueryEngine.new(query)
-    builder = engine.to_sql_builder
-    assert_includes builder.clauses, "u.address2 IS NOT NULL"
-    assert_includes builder.clauses, "length(u.address2) > 0"
-  end
-
-  test 'validate' do
-    valid_sql = "select count(*) from locations"
-    res = DataDive::QueryEngine.validate_raw_sql valid_sql
-    assert_nil res[:error]
-
-    invalid_sql = "select count(*), status, time from work_orders group by status"
-    res = DataDive::QueryEngine.validate_raw_sql invalid_sql
-    assert_not_empty res[:error]
-
-  end
-
-  test 'column types' do
-    query = TestDive.order_details
-    engine = DataDive::QueryEngine.new query
-
-    columns = engine.compute_column_metadata
-    assert_equal 12, columns.size
-
-    assert_equal 'cents', columns['Order Price'].type
-  end
-
-
-  test 'array filters' do
-    query = TestDive.employees
-    engine = DataDive::QueryEngine.new query
-    res = engine.validate
-    assert_nil res[:error]
-
-    # contains filters treat comma-separated strings as arrays and test their inclusion in the given column
-    builder = engine.to_sql_builder({'tags_1' => 'Dynamic'})
-    assert_includes builder.clauses, "u.tags @> '{\"Dynamic\"}'"
-    builder = engine.to_sql_builder({'tags_1' => 'Dynamic, Engineer'})
-    assert_includes builder.clauses, "u.tags @> '{\"Dynamic\", \"Engineer\"}'"
-
-    # any filters should match on any value shared between the two arrays
-    query = TestDive.any_array_filter
-    engine = DataDive::QueryEngine.new query
-    builder = engine.to_sql_builder({ 'tags_1' => 'Dynamic, Engineer' })
-    assert_includes builder.clauses, "u.tags && '{\"Dynamic\", \"Engineer\"}'"
-  end
-
-  test 'comma-separated filters' do
-    query = TestDive.employees
-    engine = DataDive::QueryEngine.new query
-    res = engine.validate
-    assert_nil res[:error]
-
-    builder = engine.to_sql_builder({ 'role_1' => "foo, bar" })
-    assert_includes builder.clauses, "u.role IN ('foo','bar')"
-
-  end
-
-
-end

package/test/unit/query_result_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class QueryResultTest < ActiveSupport::TestCase
-
-  test 'result' do
-
-    num = 10
-
-    raw = 0.upto(num-1).map do |i|
-      {
-          'name' => "Row #{i}",
-          'time' => Time.now+i.minutes,
-          'price' => 1000+i,
-          'number' => i+3,
-          'negative_i' => -i
-      }
-    end
-
-    result = QueryResult.new raw
-
-    tax_rate = 0.07125
-    result.compute_column 'tax' do |row|
-      row.price * tax_rate
-    end
-
-    assert_equal num, result.count
-
-    first_row = result.first
-    assert_equal 'Row 0', first_row.name
-    assert_equal 10.0, first_row.price
-    assert_in_delta first_row.price*tax_rate, first_row.tax, 0.01
-    assert_equal 3, first_row.number
-    assert_equal Time, first_row.time.class
-    assert_equal Integer, first_row.negative_i.class
-  end
-
-end

package/test/unit/regular_schedule_test.rb

@@ -1,166 +0,0 @@
-require 'test_helper'
-
-class RegularScheduleTest < ActiveSupport::TestCase
-
-  setup do
-    @daily = RegularSchedule.new(schedule_type: 'daily', hour_of_day: '14')
-    @weekdaily = RegularSchedule.new(schedule_type: 'weekdaily', hour_of_day: '14')
-    @weekly = RegularSchedule.new(schedule_type: 'weekly', hour_of_day: '14', day_of_week: 'wednesday')
-    @monthly = RegularSchedule.new(schedule_type: 'monthly', hour_of_day: '14', day_of_month: '12')
-  end
-
-  test 'daily schedule times_for_period should match every day in month' do
-    period = DatePeriod.parse('2024-05')
-    actual = @daily.times_for_period(period)
-    expected = (1..31).map { |n| Time.new(2024, 5, n, 14) }
-
-    assert_equal expected, actual
-  end
-
-  test 'weekdaily schedule times_for_period should match every weekday in month' do
-    period = DatePeriod.parse('2024-05')
-    actual = @weekdaily.times_for_period(period)
-    expected = [
-      Time.new(2024, 5, 1, 14),
-      Time.new(2024, 5, 2, 14),
-      Time.new(2024, 5, 3, 14),
-      Time.new(2024, 5, 6, 14),
-      Time.new(2024, 5, 7, 14),
-      Time.new(2024, 5, 8, 14),
-      Time.new(2024, 5, 9, 14),
-      Time.new(2024, 5, 10, 14),
-      Time.new(2024, 5, 13, 14),
-      Time.new(2024, 5, 14, 14),
-      Time.new(2024, 5, 15, 14),
-      Time.new(2024, 5, 16, 14),
-      Time.new(2024, 5, 17, 14),
-      Time.new(2024, 5, 20, 14),
-      Time.new(2024, 5, 21, 14),
-      Time.new(2024, 5, 22, 14),
-      Time.new(2024, 5, 23, 14),
-      Time.new(2024, 5, 24, 14),
-      Time.new(2024, 5, 27, 14),
-      Time.new(2024, 5, 28, 14),
-      Time.new(2024, 5, 29, 14),
-      Time.new(2024, 5, 30, 14),
-      Time.new(2024, 5, 31, 14),
-    ]
-
-    assert_equal expected, actual
-  end
-
-  test 'weekly schedule times_for_period should match every wednesday in month' do
-    period = DatePeriod.parse('2024-05')
-    actual = @weekly.times_for_period(period)
-    expected = [
-      Time.new(2024, 5, 1, 14),
-      Time.new(2024, 5, 8, 14),
-      Time.new(2024, 5, 15, 14),
-      Time.new(2024, 5, 22, 14),
-      Time.new(2024, 5, 29, 14),
-    ]
-
-    assert_equal expected, actual
-  end
-
-  test 'monthly schedule times_for_period should match 12th day of month' do
-    period = DatePeriod.parse('2024-05')
-    actual = @monthly.times_for_period(period)
-    expected = [
-      Time.new(2024, 5, 12, 14),
-    ]
-
-    assert_equal expected, actual
-  end
-
-  test 'daily schedule is_this_day? should match any day' do
-    assert_equal true, @daily.is_this_day?(Date.parse('2024-05-01'))
-  end
-
-  test 'daily schedule is_this_hour? should match correct time on any date' do
-    assert_equal true, @daily.is_this_hour?(Time.parse('2024-05-01 14:14:14'))
-  end
-
-  test 'daily schedule is_this_hour? should not match incorrect time' do
-    assert_equal false, @daily.is_this_hour?(Time.parse('2024-05-01 13:13:13'))
-  end
-
-  test 'weekly schedule is_this_day? should match monday' do
-    assert_equal true, @weekdaily.is_this_day?(Date.parse('2024-05-06'))
-  end
-
-  test 'weekly schedule is_this_day? should not match sunday' do
-    assert_equal false, @weekdaily.is_this_day?(Date.parse('2024-05-05'))
-  end
-
-  test 'weekly schedule is_this_day? should match correct day of any week' do
-    assert_equal true, @weekly.is_this_day?(Date.parse('2024-05-01'))
-  end
-
-  test 'weekly schedule is_this_day? should not match incorrect day of week' do
-    assert_equal false, @weekly.is_this_day?(Date.parse('2024-05-02'))
-  end
-
-  test 'monthly schedule is_this_day? should match correct day of month' do
-    assert_equal true, @monthly.is_this_day?(Date.parse('2024-05-12'))
-  end
-
-  test 'monthly schedule is_this_day? should not match incorrect day of month' do
-    assert_equal false, @monthly.is_this_day?(Date.parse('2024-05-13'))
-  end
-
-  test 'monthanchored schedule is_this_day? first_day should match first day of month' do
-    schedule = month_anchored_schedule(anchor: 'first_day')
-    assert_equal true, schedule.is_this_day?(Date.parse('2024-05-01'))
-  end
-
-  test 'monthanchored schedule is_this_day? first_day should not match second day of month' do
-    schedule = month_anchored_schedule(anchor: 'first_day')
-    assert_equal false, schedule.is_this_day?(Date.parse('2024-05-02'))
-  end
-
-  test 'monthanchored schedule is_this_day? first_weekday should match first of month starting on a weekday' do
-    schedule = month_anchored_schedule(anchor: 'first_weekday')
-    assert_equal true, schedule.is_this_day?(Date.parse('2024-05-01'))
-  end
-
-  test 'monthanchored schedule is_this_day? first_weekday should match first monday of month starting on a weekend' do
-    schedule = month_anchored_schedule(anchor: 'first_weekday')
-    assert_equal true, schedule.is_this_day?(Date.parse('2024-06-03'))
-  end
-
-  test 'monthanchored schedule is_this_day? first_weekday should not match first of month starting on a weekend' do
-    schedule = month_anchored_schedule(anchor: 'first_weekday')
-    assert_equal false, schedule.is_this_day?(Date.parse('2024-06-01'))
-  end
-
-  test 'monthanchored schedule is_this_day? last_weekday should match last day of month ending on a weekday' do
-    schedule = month_anchored_schedule(anchor: 'last_weekday')
-    assert_equal true, schedule.is_this_day?(Date.parse('2024-07-31'))
-  end
-
-  test 'monthanchored schedule is_this_day? last_weekday should match last friday of month ending on a weekend' do
-    schedule = month_anchored_schedule(anchor: 'last_weekday')
-    assert_equal true, schedule.is_this_day?(Date.parse('2024-06-28'))
-  end
-
-  test 'monthanchored schedule is_this_day? last_weekday should not match saturday of month' do
-    schedule = month_anchored_schedule(anchor: 'last_weekday')
-    assert_equal false, schedule.is_this_day?(Date.parse('2024-05-11'))
-  end
-
-  test 'monthanchored schedule is_this_day? last_day should match last day of month' do
-    schedule = month_anchored_schedule(anchor: 'last_day')
-    assert_equal true, schedule.is_this_day?(Date.parse('2024-05-31'))
-  end
-
-  test 'monthanchored schedule is_this_day? last_day should not match day before last day of month' do
-    schedule = month_anchored_schedule(anchor: 'last_day')
-    assert_equal false, schedule.is_this_day?(Date.parse('2024-05-30'))
-  end
-
-  def month_anchored_schedule(anchor:)
-    RegularSchedule.new(schedule_type: 'monthanchored', hour_of_day: '14', anchor:)
-  end
-
-end

package/test/unit/schedule_rule_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-class ScheduleRuleTest < ActiveSupport::TestCase
-
-  test 'every other week' do
-    rule1 = ScheduleRule.new days: %w(tuesday), weeks: %w(1 3 5), months: ScheduleRule.months
-    assert_equal 28, rule1.num_per_year
-    rule2 = ScheduleRule.new days: %w(tuesday), weeks: %w(2 4), months: ScheduleRule.months
-    assert_equal 24, rule2.num_per_year
-    rule = ScheduleRule.new days: %w(tuesday), weeks: %w(every_2), months: ScheduleRule.months
-    assert_equal 26, rule.num_per_year
-    assert_equal 2, rule.num_per_month['february']
-  end
-
-  test 'fifth week' do
-    rule = ScheduleRule.new days: %w(tuesday), weeks: %w(5), months: ScheduleRule.months
-    assert_equal 4, rule.num_per_year
-    rule = ScheduleRule.new days: %w(tuesday), weeks: %w(2 5), months: ScheduleRule.months
-    assert_equal 16, rule.num_per_year
-    rule = ScheduleRule.new days: %w(tuesday), weeks: %w(1 2 3 5), months: ScheduleRule.months
-    assert_equal 40, rule.num_per_year
-  end
-
-  test 'contains' do
-    rule = ScheduleRule.new days: %w(tuesday), weeks: ['all'], months: ScheduleRule.months
-    assert rule.contains_day?(Time.parse('2017-09-05'))
-    assert !rule.contains_day?(Time.parse('2017-09-04'))
-  end
-
-
-end

package/test/unit/string_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class StringTest < ActiveSupport::TestCase
-
-  test 'truthiness' do
-    assert 'true'.is_true?
-    assert '1'.is_true?
-    assert 'T'.is_true?
-    assert 'on'.is_true?
-    assert !'off'.is_true?
-    assert 'off'.is_false?
-    assert !'foo'.is_false?
-    assert '0'.is_false?
-    assert !'true'.is_false?
-  end
-
-  test 'without_parens' do
-    assert_equal 'hello world', "hello world (remove)".without_parens
-    assert_equal 'hello world', "hello world ((foo bar1))".without_parens
-    assert_equal 'hello world', "hello world ((foo, bar1 & *%@ 123 123#&%)".without_parens
-    assert_equal 'Fumigation', "Fumigation (2+ rail car/trailer/unit))".without_parens
-  end
-
-  test 'postgres_array_literal' do
-    assert_equal '{"jim", "joe", "jess"}', %w(jim joe jess).to_postgres_array_literal
-  end
-
-end
-