marty 6.1.0 → 8.0.0

data/spec/features/inline_editing_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+feature 'Inline editing', js: true do
+  before do
+    populate_test_users
+  end
+
+  it 'Adds a new record with default false value in checkbox' do
+    log_in_as('marty')
+    press('Pricing Config.')
+    press('Gemini Simple')
+    wait_for_ajax
+
+    grid = netzke_find('simple_view')
+    press 'Add'
+
+    row = grid.select_row(1)
+    user_id = row.all('.x-grid-cell')[0]
+    name = row.all('.x-grid-cell')[1]
+
+    user_id.double_click
+    user_id.fill_in 'user_id', with: 1
+
+    name.double_click
+    name.fill_in 'some_name', with: 'test name'
+
+    press 'Apply'
+    wait_for_ajax
+
+    model = Gemini::Simple.find_by(some_name: 'test name')
+    expect(model.active).to be false
+  end
+end

data/spec/features/rule_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-feature 'rule view', js: true do
+feature 'rule view', js: true, speed: :slow do
   before(:all) do
     marty_whodunnit
     @save_file = "/tmp/save_#{Process.pid}.psql"

data/spec/features/schedule_jobs_dashboard_spec.rb

@@ -22,7 +22,7 @@ feature 'Schedule Jobs Dashboard', js: true do
   end
 
   context 'as admin' do
-    let(:schedule_view) { netzke_find('schedule_jobs_dashboard') }
+    let(:schedule_view) { netzke_find('schedule_jobs_grid') }
 
     let!(:schedule) do
       Marty::BackgroundJob::Schedule.create(

data/spec/features/scripting_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-feature 'under Applications menu, Scripting workflows', js: true do
+feature 'under Applications menu, Scripting workflows', js: true, speed: :slow do
   before(:all) do
     self.use_transactional_tests = false
 

data/spec/features/user_list_report_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+feature 'User List report', js: true do
+  before(:each) do
+    populate_test_users
+    Marty::Script.load_scripts(nil)
+  end
+
+  def go_to_reporting
+    press('Applications')
+    press('Reports')
+  end
+
+  def with_user(uname)
+    u = Marty::User.find_by_login(uname)
+    begin
+      old_u, Mcfly.whodunnit = Mcfly.whodunnit, u
+      yield(u)
+    ensure
+      Mcfly.whodunnit = old_u
+    end
+  end
+
+  def select_node node_name
+    wait_for_ajax
+    # hacky: assumes only 1 combobox without label
+    within(:gridpanel, 'report_select', match: :first) do
+      # hacky, hardcoding netzkecombobox dropdown arrow name
+      arrow = find(:input, 'nodename')['data-componentid'] + '-trigger-picker'
+      find(:xpath, ".//div[@id='#{arrow}']").click
+      find(:xpath, "//li[text()='#{node_name}']").click
+    end
+  end
+
+  it 'run_script displays proper data' do
+    log_in_as('admin1')
+    go_to_reporting
+
+    tag_grid = netzke_find('tag_grid')
+    script_grid = netzke_find('script_grid')
+    posting_combo = netzke_find('Posting', 'combobox')
+    script_combo = netzke_find('', 'combobox')
+
+    by 'select tag' do
+      wait_for_ajax
+      tag_grid.select_row(1)
+    end
+
+    and_by 'select TableReport script & UserList node' do
+      find('table', text: 'TableReport').click
+      select_node('User List (csv)')
+    end
+
+    and_by 'generate report' do
+      wait_for_ajax
+      press('Generate Report')
+      wait_for_ajax
+      expect(page).to have_content('Generate: User List')
+    end
+
+    path = Rails.root.join('spec/tmp/downloads/User List.csv')
+    csv_content = CSV.parse File.read(path)
+
+    expect(csv_content.size > 1).to be true
+    expect(csv_content.first).to eq ['login', 'firstname', 'lastname', 'active', 'roles']
+
+    expected_row = [
+      'marty', 'marty', 'marty', 'true',
+      'admin, data_grid_editor, dev, user_manager, viewer'
+    ]
+    marty_row = csv_content.find { |row| row[0] == 'marty' }
+    expect(marty_row).to eq expected_row
+  end
+end

data/spec/fixtures/misc/struct_compare_tests.txt

@@ -57,12 +57,12 @@
 { "example_number": "11",
   "v1": [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
   "v2": [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[["one"]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
-  "res": "path=[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0] class mismatch Integer String"
+  "res": "path=[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0] class mismatch Integer (1) != String (one)"
 },
 { "example_number": "12",
   "v1": [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
   "v2": [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
-  "res": "path=[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0] class mismatch Array Integer"
+  "res": "path=[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0] class mismatch Array != Integer (1)"
 },
 { "example_number": "13",
   "v1": [{"a": 1, "b": 2, "c": 3, "d": 4},
@@ -118,12 +118,12 @@
 { "example_number": "21",
   "v1": [[[1,2,3], {"foo": "bar", "baz": null, "plugh": 2.434, "hash": { "value": [1,2] }}], 7, "value"],
   "v2": [[[1,2,3], {"foo": "bar", "baz": false, "plugh": 2.434, "hash": { "value": [1,2] }}], 7, "value"],
-  "res": "path=[0][1][\"baz\"] class mismatch NilClass FalseClass"
+  "res": "path=[0][1][\"baz\"] class mismatch NilClass != FalseClass"
 },
 { "example_number": "22",
   "v1": [[[1,2,3], {"foo": "bar", "baz": true, "plugh": 2.434, "hash": { "value": [1,false] }}], 7, "value"],
   "v2": [[[1,2,3], {"foo": "bar", "baz": true, "plugh": 2.434, "hash": { "value": [1,null] }}], 7, "value"],
-  "res": "path=[0][1][\"hash\"][\"value\"][1] class mismatch FalseClass NilClass"
+  "res": "path=[0][1][\"hash\"][\"value\"][1] class mismatch FalseClass != NilClass"
 },
 { "example_number": "23",
   "v1": {"pi": 3.1415926, "e": 2.7182818, "phi": 1.618034},
@@ -158,7 +158,7 @@
 { "example_number": "29",
   "v1": {"three": 3},
   "v2": {"three": 3.0},
-  "res": "path=[\"three\"] class mismatch Integer Float",
+  "res": "path=[\"three\"] class mismatch Integer (3) != Float (3.0)",
   "cmp_opts": {"float_int_nomatch": true}
 },
 { "example_number": "30",
@@ -166,5 +166,15 @@
   "v2": {"three": 3.0, "dummy": "bye", "dummy2": 2},
   "res": false,
   "cmp_opts": {"float_int_nomatch": false, "ignore": ["dummy", "dummy2"]}
+},
+{ "example_number": "31",
+  "v1": {"a": 1},
+  "v2": {"a": [1]},
+  "res": "path=[\"a\"] class mismatch Integer (1) != Array"
+},
+{ "example_number": "32",
+  "v1": {"a": 1},
+  "v2": {"a": {"b": 1}},
+  "res": "path=[\"a\"] class mismatch Integer (1) != Hash"
 }
 ]

data/spec/job_helper.rb

@@ -110,6 +110,43 @@ LOGGER:
              Gemini::Helper.testaction('message %d', msgid) && msgid
 EOS
 
+NAME_M = 'PromiseM'
+SCRIPT_M = <<EOS
+Node:
+    secs =?
+    label =?
+    reverse =? false
+    job_cnt =?
+    call_sleep = Gemini::Helper.sleep(secs, label)
+    blocker_inds = Gemini::Helper.get_inds(8)
+    blocker_calls = [Node(secs=5,
+                     p_title = "Blocker %d" % i,
+                     label = "Blocker %d" % i) | "call_sleep"
+                for i in blocker_inds]
+    prio_inds = Gemini::Helper.get_inds(job_cnt)
+    prios = [(if reverse then job_cnt - i else i)
+             for i in prio_inds]
+    prio_both = prio_inds.zip(prios)
+    prio_calls = [
+        Node(secs=2,
+             p_title = "Prioritized %d pri=%d" % [i, prio],
+             label = "Prioritized %d pri=%d" % [i, prio],
+             p_priority = prio) | "call_sleep"
+        for i, prio in prio_both]
+    result = blocker_calls + prio_calls
+EOS
+
+NAME_N = 'PromiseN'
+SCRIPT_N = <<EOS
+Node:
+    title =?
+    child1 = Gemini::Helper.sleep(0, 'child1')
+    child2 = Gemini::Helper.sleep(0, 'child2')
+
+    result = [Node(p_title=title + ' child1') | "child1",
+              Node(p_title=title + ' child2', p_priority=10) | "child2"]
+EOS
+
 def promise_bodies
   {
     NAME_A => SCRIPT_A,
@@ -123,5 +160,7 @@ def promise_bodies
     NAME_I => SCRIPT_I,
     NAME_J => SCRIPT_J,
     NAME_K => SCRIPT_K,
+    NAME_M => SCRIPT_M,
+    NAME_N => SCRIPT_N,
   }
 end

data/spec/jobs/cron_job_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe 'Cron jobs' do
+  let(:klass) { TestFailingJob }
+
+  let!(:schedule) do
+    Marty::BackgroundJob::Schedule.create!(
+      job_class: klass.name,
+      cron: '* * * * *',
+      state: 'on'
+    ).tap do |job|
+      Marty::BackgroundJob::UpdateSchedule.call(
+        id: job.id,
+        job_class: job.job_class
+      )
+
+      dj = klass.delayed_job
+      dj.update!(run_at: 1.minute.ago)
+    end
+  end
+
+  def run_job
+    expect(klass.delayed_job).to be_present
+    expect(Delayed::Job.count).to eq 1
+    worker = Delayed::Worker.new
+    worker.work_off
+  end
+
+  describe 'when delayed_job record is deleted during the execution' do
+    describe 'after failure' do
+      context 'schedule is on' do
+        before do
+          run_job
+        end
+
+        it 'job is recreated' do
+          expect(klass).to be_scheduled
+          expect(klass.delayed_job).to be_present
+        end
+      end
+
+      context 'schedule is off' do
+        before do
+          schedule.update!(state: :off)
+          run_job
+        end
+
+        it 'job is not recreated' do
+          expect(klass).to_not be_scheduled
+          expect(klass.delayed_job).to_not be_present
+        end
+      end
+    end
+
+    describe 'after success' do
+      before do
+        allow(klass).to receive(:trigger_failure).and_return(nil)
+        run_job
+      end
+
+      it 'job is not recreated' do
+        expect(klass).to_not be_scheduled
+        expect(klass.delayed_job).to_not be_present
+      end
+    end
+  end
+
+  describe 'logs' do
+    before do
+      allow(klass).to receive(:trigger_destroy).and_return(nil)
+    end
+
+    it 'logs failure' do
+      expect { run_job }.to change { Marty::BackgroundJob::Log.count }.by 1
+      log = Marty::BackgroundJob::Log.find_by(job_class: klass.name)
+      expect(log.error).to be_present
+      expect(log.failure?).to be true
+      expect(klass).to be_scheduled
+    end
+
+    it 'logs success' do
+      allow(klass).to receive(:trigger_failure).and_return(nil)
+
+      expect { run_job }.to change { Marty::BackgroundJob::Log.count }.by 1
+      log = Marty::BackgroundJob::Log.find_by(job_class: klass.name)
+      expect(log.error).to_not be_present
+      expect(log.success?).to be true
+      expect(klass).to be_scheduled
+    end
+  end
+end

data/spec/lib/mcfly_model_spec.rb

@@ -99,16 +99,25 @@ describe 'McflyModel' do
     Marty::Script.load_script_bodies({ 'E6' => (errscript3 % 'b_func_p') }, dt)
 
     @engine = Marty::ScriptSet.new.get_engine('AA')
+
+    mcfly_cache_adapter = ::Marty::CacheAdapters::McflyRubyCache.new(
+      size_per_class: 1000
+    )
+
+    ::Delorean::Cache.adapter = mcfly_cache_adapter
   end
+
   after(:all) do
     restore_clean_db(@clean_file)
     Marty::ScriptSet.clear_cache
   end
+
   let(:params) do
     { 'pt' => 'infinity',
                  'entity'    => Gemini::Entity.all.first,
                  'note_rate' => 2.875 }
   end
+
   it 'lookup mode default' do
     a1 = @engine.evaluate('A', 'lookup', params)
     a2 = @engine.evaluate('A', 'clookup', params)

data/spec/models/promise_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'job_helper'
 
-describe Marty::Promise, slow: true do
+describe Marty::Promise, slow: true, retry: 3 do
   before(:all) do
     @clean_file = "/tmp/clean_#{Process.pid}.psql"
     save_clean_db(@clean_file)
@@ -18,6 +18,7 @@ describe Marty::Promise, slow: true do
   end
 
   before(:each) do
+    ActiveRecord::Base.connection.reconnect!
     @time = DateTime.now
     expect(Marty::Promise.count).to eq(0)
     engine = Marty::ScriptSet.new.get_engine(NAME_A)
@@ -28,6 +29,7 @@ describe Marty::Promise, slow: true do
   end
 
   after(:each) do
+    ActiveRecord::Base.connection.reconnect!
     Marty::Log.delete_all
     Marty::Promise.where('parent_id IS NULL').destroy_all
     Timecop.return
@@ -208,4 +210,169 @@ describe Marty::Promise, slow: true do
       expect(promise.result['backtrace']).to_not be_empty
     end
   end
+
+  describe 'priority' do
+    let(:user) { Marty::User.find_by(login: 'marty') }
+
+    def run_prio_test(reverse: false, title:, runner:, job_cnt:)
+      real_title = title + ' ' + reverse.to_s
+      runner.call(reverse, real_title, job_cnt)
+      base_p = nil
+      timeout = 60
+      # wait until base promise completes
+      loop do
+        base_p = Marty::Promise.find_by(title: real_title)
+        break if p&.status || timeout == 0
+
+        timeout -= 1
+        sleep 1
+      end
+      [base_p, timeout]
+    end
+
+    it 'allows priority to be set' do
+      ruby_runner = lambda do |reverse, title, job_cnt|
+        Marty::Promises::Ruby::Create.call(
+          module_name: 'Gemini::Helper',
+          method_name: 'priority_tester',
+          method_args: [reverse, job_cnt],
+          params: { p_title: title, _user_id: user.id }
+        )
+      end
+
+      engine = Marty::ScriptSet.new.get_engine(NAME_M)
+      dl_runner = lambda do |reverse, title, job_cnt|
+        result = engine.background_eval('Node',
+                                        { 'p_title' => title,
+                                          'job_cnt' => job_cnt,
+                                          'reverse' => reverse }, ['result'])
+      end
+
+      results = []
+      job_cnt = 40
+      [['Ruby', ruby_runner],
+       ['Delorean', dl_runner]].each do |type, runner|
+        [true, false].each do |prio_order|
+          base_pr, timeout = run_prio_test(runner: runner,
+                                           title: 'Priority Base',
+                                           reverse: prio_order,
+                                           job_cnt: job_cnt)
+          expect(base_pr.is_a?(Marty::Promise)).to be_truthy
+          expect(base_pr.status).to be_truthy
+          expect(timeout).to be < 45
+          r = base_pr.result(true)['result']
+          expect(r.count).to eq(job_cnt + 8)
+          expect(r.to_set).to eq(Set.new(['5', '2']))
+
+          logs = Marty::Log.all.order(:id).attributes
+          Marty::Log.destroy_all
+          results << [type, prio_order, logs]
+        end
+      end
+
+      aggregate_failures do
+        results.each do |type, dirflag, logs|
+          err_str = "Type = #{type}, reverse=#{dirflag}"
+
+          # look at the log in order to see how the jobs ran
+          run_order = logs.map do |l|
+            label = l.dig('details', 'label')
+            label.starts_with?('Blocker') ? nil : label
+          end.compact
+
+          # get the priorities from the ordered list
+          pris = run_order.map do |r|
+            r.match(/pri=(\d+)/)[1].to_i
+          end
+          pc = pris.count
+
+          #####################################################################
+          # even though jobs start in order, variations in how they run (due to
+          # os scheduling) are still possible. Also, 'run off' jobs usually run
+          # out of order. Expect the log to be mostly in order (for any job,
+          # most of the jobs that ran before it should be lower and most after
+          # should be higher)
+          #####################################################################
+
+          # for each priority (job run) compute a score based on how many lower
+          # priority jobs preceeded it and higher priority jobs followed it.
+          comps = Array.new(pc) do |ind|
+            lhs = ind - 1
+            rhs = ind + 1
+            lha = lhs > -1 ? pris[0..lhs] : []        # jobs that ran before
+            rha = rhs <= pc - 1 ? pris[rhs..-1] : []  # jobs that ran after
+
+            # score is an array of t/f ; t indicates correct ordering
+            score = lha.map { |v| v < pris[ind] } + rha.map { |v| v > pris[ind] }
+          end
+
+          # count the trues for each job
+          scores = comps.map { |a| a.count { |v| v } }
+
+          avg_score = scores.sum.to_f / scores.count
+          target = job_cnt * 0.75
+
+          expect(avg_score).to be >= target
+        end
+      end
+    end
+
+    it 'inherits priority from parent' do
+      ruby_runner = lambda do |priority = nil|
+        title = "Ruby pri=#{priority}"
+        params = { p_title: title,
+                   _user_id: user.id,
+                   p_priority: priority }.compact
+        Marty::Promises::Ruby::Create.call(
+          module_name: 'Gemini::Helper',
+          method_name: 'priority_inh_tester',
+          method_args: [title],
+          params: params
+        )
+        title
+      end
+      engine = Marty::ScriptSet.new.get_engine(NAME_N)
+      dl_runner = lambda do |priority = nil|
+        title = "Delorean pri=#{priority}"
+        result = engine.background_eval('Node',
+                                        { 'p_title' => title,
+                                          'title' => title,
+                                          'p_priority' => priority }.compact,
+                                        ['result'])
+        title
+      end
+      results = []
+      [ruby_runner,
+       dl_runner].each do |runner|
+        [nil, 123].each do |priority|
+          title = runner.call(priority)
+          timeout = 10
+          r = nil
+          loop do
+            r = Marty::Promise.where("title like '#{title}%'").order(:title).
+                  pluck(:title, :priority)
+            break if r.count == 3 || timeout == 0
+
+            timeout -= 1
+            sleep 1
+          end
+          results << r
+        end
+      end
+      # child1 should have same priority as parent, child2 should have 10
+      exp = [[['Ruby pri=', 0],
+              ['Ruby pri= child1', 0],
+              ['Ruby pri= child2', 10]],
+             [['Ruby pri=123', 123],
+              ['Ruby pri=123 child1', 123],
+              ['Ruby pri=123 child2', 10]],
+             [['Delorean pri=', 0],
+              ['Delorean pri= child1', 0],
+              ['Delorean pri= child2', 10]],
+             [['Delorean pri=123', 123],
+              ['Delorean pri=123 child1', 123],
+              ['Delorean pri=123 child2', 10]]]
+      expect(results).to eq(exp)
+    end
+  end
 end