marty 2.6.4 → 2.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d525319e98d55b25d7ac47f40a085b1d3759f67bf400bfcecd3908fb6ed8c6e8
-  data.tar.gz: e3276f7391957c7fa615f2af1702944ff7a43aefd253d9e660e5c0f3cb637f1d
+  metadata.gz: 1cabd5f09c9dce0fee4129f0bf6fe90b9c92443db0e6ce2ba6703a56c5b1e067
+  data.tar.gz: 336101e0514a022e49c96709664a881121d42b6d54497f9eede865c89d4470b9
 SHA512:
-  metadata.gz: 17a54c4a4e197cd114665cf83113eac00d16350501739e435080b68666ce8f78845a09d38af5cede910187b44736f4a8a0e715d2a37df7b19c541b202361e560
-  data.tar.gz: 92f6af0854f0d5965203669164c63370a7ad70a5d1666d9115d13a540a11828f4cfe64a69c45ac0c27a9c40e660cdff23e77440113b2cd2bef8b734248b31bd3
+  metadata.gz: 6b5cae6730109621e2a8334ec31a1b4a045cf11d551bfa6e13aa9784454a4c67e4573818a2d6a1ed92c00bedd63d51f896fe3be017868c3a4f0baf84f96a97d8
+  data.tar.gz: 59a70afb17b02d6b944c0c492f7d1db9105c17e6f69aed36fda844bf9e2400cf3a76722fbec5e202cb3fed579fd3c1a241e67faa58750996e2c9b7a0cf0be173

data/.gitlab-ci.yml

@@ -12,7 +12,7 @@ before_script:
   stage: test
   # Use only the following CI runners
   tags:
-    - cf-gitlabci-runner-eks-shared-dev
+    - gitlabci-runner-eks-shared-dev
 
 rubocop:
   extends: .base-test
@@ -28,6 +28,7 @@ rspec-features:
   extends: .base-test
   script:
     - ln -s /opt/support/extjs /cm_tech/marty/spec/dummy/public/extjs
+    - chromedriver-update 73.0.3683.68
     # - bundle exec rspec --pattern "spec/features/**/*_spec.rb"
     # FIXME: rule_spec is excluded, because chrome doesn't work with big window size in docker
     # And test fails with 1400/1400 resolution

data/.rubocop_todo.yml

@@ -1122,6 +1122,7 @@ Style/StringLiteralsInInterpolation:
 Style/StructInheritance:
   Exclude:
     - 'lib/marty/promise_job.rb'
+    - 'lib/marty/promise_ruby_job.rb'
 
 # Offense count: 75
 # Cop supports --auto-correct.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (2.6.2)
+    marty (2.6.5)
       aws-sigv4 (~> 1.0, >= 1.0.2)
       axlsx (= 3.0.0pre)
       coderay
@@ -62,7 +62,9 @@ GEM
       io-like (~> 0.3.0)
     arel (8.0.0)
     ast (2.4.0)
-    aws-sigv4 (1.0.3)
+    aws-eventstream (1.0.3)
+    aws-sigv4 (1.1.0)
+      aws-eventstream (~> 1.0, >= 1.0.2)
     axlsx (3.0.0.pre)
       htmlentities (~> 4.3, >= 4.3.4)
       mimemagic (~> 0.3)

data/app/models/marty/enum_promise_type.rb

@@ -0,0 +1,5 @@
+class Marty::EnumPromiseType < Marty::Base
+  extend Marty::PgEnum
+
+  VALUES = Set['delorean', 'ruby']
+end

data/app/models/marty/promise.rb

@@ -10,44 +10,16 @@ class Marty::Promise < Marty::Base
     Marty::Promise.load_result(res, force)
   end
 
-  def self.load_result(obj, force = false)
-    if force && obj.respond_to?(:__force__)
-      obj = obj.__force__
-    end
-
-    case obj
-    when Array
-      obj.map { |x| load_result(x, force) }
-    when Hash
-      p = obj['__promise__']
-
-      if p && obj.length == 1
-        load_result(Marty::PromiseProxy.new(*p), force)
-      else
-        obj.each_with_object({}) { |(k, v), h| h[k] = load_result(v, force) }
-      end
-    else
-      obj
-    end
-  end
-
   has_many :children,
            foreign_key: 'parent_id',
            class_name: 'Marty::Promise',
            dependent: :destroy
 
-  validates_presence_of :title
+  validates_presence_of :title, :promise_type
 
   belongs_to :parent, class_name: 'Marty::Promise'
   belongs_to :user, class_name: 'Marty::User'
 
-  def self.cleanup(all = false)
-      where('start_dt < ? AND parent_id IS NULL',
-            DateTime.now - (all ? 0.hours : 4.hours)).destroy_all
-  rescue StandardError => exc
-      Marty::Util.logger.error("promise GC error: #{exc}")
-  end
-
   def raw_conn
     self.class.connection.raw_connection
   end
@@ -162,8 +134,8 @@ class Marty::Promise < Marty::Base
             work_off_job(job)
           rescue StandardError => exc
             # log "OFFERR #{exc}"
-            res = Delorean::Engine.grok_runtime_exception(exc)
-            last.set_result(res)
+            error = exception_to_result(exc)
+            last.set_result(error)
           end
           # log "OFF1 #{Process.pid} #{last}"
         end
@@ -211,4 +183,48 @@ class Marty::Promise < Marty::Base
       result: promise.result
     }
   end
+
+  def delorean?
+    promise_type == 'delorean'
+  end
+
+  class << self
+    def load_result(obj, force = false)
+      if force && obj.respond_to?(:__force__)
+        obj = obj.__force__
+      end
+
+      case obj
+      when Array
+        obj.map { |x| load_result(x, force) }
+      when Hash
+        p = obj['__promise__']
+
+        if p && obj.length == 1
+          load_result(Marty::PromiseProxy.new(*p), force)
+        else
+          obj.each_with_object({}) { |(k, v), h| h[k] = load_result(v, force) }
+        end
+      else
+        obj
+      end
+    end
+
+    def cleanup(all = false)
+      where(
+        'start_dt < ? AND parent_id IS NULL',
+        DateTime.now - (all ? 0.hours : 4.hours)
+      ).destroy_all
+    rescue StandardError => exc
+        Marty::Util.logger.error("promise GC error: #{exc}")
+    end
+
+    def exception_to_result(promise:, exception:)
+      if promise.delorean?
+        return Delorean::Engine.grok_runtime_exception(exception)
+       end
+
+      { 'error' => exception.message, 'backtrace' => exception.backtrace }
+    end
+  end
 end

data/app/services/marty/promises/delorean.rb

@@ -0,0 +1,6 @@
+module Marty
+  module Promises
+    module Delorean
+    end
+  end
+end

data/app/services/marty/promises/delorean/create.rb

@@ -0,0 +1,75 @@
+module Marty
+  module Promises
+    module Delorean
+      module Create
+        def self.call(params:, script:, node_name:, attr:, args:, tag:)
+          default_timeout = Marty::Promise::DEFAULT_PROMISE_TIMEOUT
+
+          title = params['p_title'] || "#{script}::#{node_name.demodulize}"
+          timeout = params['p_timeout'] || default_timeout
+          hook = params['p_hook']
+
+          promise = Marty::Promise.create(
+            title: title,
+            user_id: params[:_user_id],
+            parent_id: params[:_parent_id],
+            promise_type: 'delorean'
+          )
+
+          params[:_promise_id] = promise.id
+
+          begin
+            promise_job = Marty::PromiseJob.new(
+              promise,
+              title,
+              script,
+              tag,
+              node_name,
+              params,
+              args,
+              hook
+            )
+
+            job = Delayed::Job.enqueue(promise_job)
+          rescue StandardError => exc
+            # log "CALLERR #{exc}"
+            res = ::Delorean::Engine.grok_runtime_exception(exc)
+            promise.set_start
+            promise.set_result(res)
+            # log "CALLERRSET #{res}"
+            raise
+          end
+
+          # keep a reference to the job. This is needed in case we want to
+          # work off a promise job that we're waiting for and which hasn't
+          # been reserved yet.
+          promise.job_id = job.id
+          promise.save!
+
+          evh = params['p_event']
+          if evh
+            event, klass, subject_id, operation = evh.values_at(
+              'event',
+              'klass',
+              'id',
+              'operation'
+            )
+
+            if event
+              event.promise_id = promise.id
+              event.save!
+            else
+              Marty::Event.create!(
+                promise_id: promise.id,
+                klass: klass,
+                subject_id: subject_id,
+                enum_event_operation: operation
+              )
+            end
+          end
+          Marty::PromiseProxy.new(promise.id, timeout, attr)
+        end
+      end
+    end
+  end
+end

data/app/services/marty/promises/ruby.rb

@@ -0,0 +1,6 @@
+module Marty
+  module Promises
+    module Ruby
+    end
+  end
+end

data/app/services/marty/promises/ruby/create.rb

@@ -0,0 +1,44 @@
+module Marty
+  module Promises
+    module Ruby
+      module Create
+        def self.call(module_name:, method_name:, method_args:, params: {})
+          default_timeout = Marty::Promise::DEFAULT_PROMISE_TIMEOUT
+
+          promise_params = params.with_indifferent_access
+
+          title = promise_params['p_title'] || "#{module_name}.#{method_name}"
+          timeout = promise_params['p_timeout'] || default_timeout
+          hook = promise_params['p_hook']
+
+          promise = Marty::Promise.create(
+            title: title,
+            user_id: promise_params[:_user_id],
+            parent_id: promise_params[:_parent_id],
+            promise_type: 'ruby'
+          )
+
+          begin
+            promise_job = Marty::PromiseRubyJob.new(
+              promise,
+              title,
+              module_name,
+              method_name,
+              method_args,
+              hook
+            )
+
+            job = Delayed::Job.enqueue(promise_job)
+          rescue StandardError => exc
+            res = { 'error' => exc.message }
+            promise.set_start
+            promise.set_result(res)
+            raise
+          end
+
+          Marty::PromiseProxy.new(promise.id, timeout, 'result')
+        end
+      end
+    end
+  end
+end

data/db/migrate/502_add_promise_type_enum.rb

@@ -0,0 +1,15 @@
+class AddPromiseTypeEnum < ActiveRecord::Migration[4.2]
+  def up
+    values = Marty::EnumPromiseType::VALUES
+    str_values = values.map {|v| ActiveRecord::Base.connection.quote v}.join ','
+    execute <<-SQL
+       CREATE TYPE marty_promise_types AS ENUM (#{str_values})
+    SQL
+  end
+
+  def down
+    execute <<-SQL
+       DROP TYPE marty_promise_types
+    SQL
+  end
+end

data/db/migrate/503_add_promise_type_to_promises.rb

@@ -0,0 +1,13 @@
+class AddPromiseTypeToPromises < ActiveRecord::Migration[4.2]
+  def up
+    add_column :marty_promises, :promise_type, :marty_promise_types
+
+    Marty::Promise.update_all(promise_type: 'delorean')
+
+    change_column :marty_promises, :promise_type, :marty_promise_types, null: false
+  end
+
+  def down
+    remove_column :marty_promises, :promise_type
+  end
+end

data/lib/marty/monkey.rb

@@ -22,6 +22,70 @@ end
 
 ######################################################################
 
+# Patch Delorean to work with promises
+
+class Delorean::BaseModule::NodeCall
+  def initialize(_e, engine, node, params)
+    super
+
+    # If call has a promise_id (i.e. is from a promise) then that's
+    # our parent.  Otherwise, we use its parent as our parent.
+    params[:_parent_id] = _e[:_promise_id] || _e[:_parent_id]
+    params[:_user_id]   = _e[:_user_id]    || Mcfly.whodunnit.try(:id)
+  end
+
+  # def log(msg)
+  #   open('/tmp/dj.out', 'a') { |f| f.puts msg }
+  # end
+
+  # Monkey-patch '|' method for Delorean NodeCall to create promise
+  # jobs and return promise proxy objects.
+  def |(args)
+    if args.is_a?(String)
+      attr = args
+      args = [attr]
+    else
+      raise 'bad arg to %' unless args.is_a?(Array)
+
+      attr = nil
+    end
+    script, tag = engine.module_name, engine.sset.tag
+    nn = node.is_a?(Class) ? node.name : node.to_s
+    begin
+      # make sure params is serialzable before starting a Job
+      JSON.dump(params)
+    rescue StandardError => exc
+      raise "non-serializable parameters: #{params} #{exc}"
+    end
+
+    Marty::Promises::Delorean::Create.call(
+      params: params,
+      script: script,
+      node_name: nn,
+      attr: attr,
+      args: args,
+      tag: tag
+    )
+  end
+end
+
+class Delorean::Engine
+  def background_eval(node, params, attrs, event = {})
+    raise 'background_eval bad params' unless params.is_a?(Hash)
+
+    unless event.empty?
+      params['p_event'] = event.each_with_object({}) do |(k, v), h|
+        h[k.to_s] = v
+      end
+    end
+    nc = Delorean::BaseModule::NodeCall.new({}, self, node, params)
+    # start the background promise
+    nc | attrs
+  end
+end
+
+######################################################################
+
 class Hash
   # define addition on hashes -- useful in Delorean code.
   def +(x)

data/lib/marty/permissions.rb

@@ -59,4 +59,33 @@ module Marty::Permissions
   def has_any_perm?
     !(current_user_roles & ALL_ROLES).empty?
   end
+
+  # FIXME: for backwards compatibility returns true
+  # if permission is not specified in has_marty_permissions
+
+  NETZKE_ENDPOINTS = [:create, :read, :update, :delete].freeze
+
+  def can_call_endpoint?(endpoint)
+    # Netzke endpoints access is controlled by Netzke permissions
+    return true if NETZKE_ENDPOINTS.include?(endpoint.to_sym)
+
+    return true unless respond_to?(:marty_permissions)
+    return true unless marty_permissions.key?(endpoint.to_sym)
+
+    can_perform_action?(endpoint)
+  end
+
+  # FIXME: hack to override Netzke invoke endpoint
+  # for classes with Marty::Permissions
+  def self.extended(mod)
+    mod.class_exec do
+      def invoke_endpoint(endpoint, params, configs = [])
+        return super(endpoint, params, configs) if self.class.can_call_endpoint?(endpoint)
+
+        self.client = Netzke::Core::EndpointResponse.new
+        client.netzke_notify 'Permission Denied'
+        client
+      end
+    end
+  end
 end

data/lib/marty/promise_job.rb

@@ -1,100 +1,5 @@
 require 'delorean_lang'
 
-class Delorean::BaseModule::NodeCall
-  def initialize(_e, engine, node, params)
-    super
-
-    # If call has a promise_id (i.e. is from a promise) then that's
-    # our parent.  Otherwise, we use its parent as our parent.
-    params[:_parent_id] = _e[:_promise_id] || _e[:_parent_id]
-    params[:_user_id]   = _e[:_user_id]    || Mcfly.whodunnit.try(:id)
-  end
-
-  # def log(msg)
-  #   open('/tmp/dj.out', 'a') { |f| f.puts msg }
-  # end
-
-  # Monkey-patch '|' method for Delorean NodeCall to create promise
-  # jobs and return promise proxy objects.
-  def |(args)
-    if args.is_a?(String)
-      attr = args
-      args = [attr]
-    else
-      raise 'bad arg to %' unless args.is_a?(Array)
-
-      attr = nil
-    end
-    script, tag = engine.module_name, engine.sset.tag
-    nn = node.is_a?(Class) ? node.name : node.to_s
-    begin
-      # make sure params is serialzable before starting a Job
-      JSON.dump(params)
-    rescue StandardError => exc
-      raise "non-serializable parameters: #{params} #{exc}"
-    end
-
-    # log "||||| #{args.inspect} #{params.inspect}"
-
-    title   = params['p_title']   || "#{script}::#{nn.demodulize}"
-    timeout = params['p_timeout'] || Marty::Promise::DEFAULT_PROMISE_TIMEOUT
-    hook    = params['p_hook']
-    promise = Marty::Promise.
-      create(title:     title,
-             user_id:   params[:_user_id],
-             parent_id: params[:_parent_id],
-            )
-    params[:_promise_id] = promise.id
-    begin
-      job = Delayed::Job.enqueue Marty::PromiseJob.
-        new(promise, title, script, tag, nn, params, args, hook)
-    rescue StandardError => exc
-      # log "CALLERR #{exc}"
-      res = Delorean::Engine.grok_runtime_exception(exc)
-      promise.set_start
-      promise.set_result(res)
-      # log "CALLERRSET #{res}"
-      raise
-    end
-
-    # keep a reference to the job.  This is needed in case we want to
-    # work off a promise job that we're waiting for and which hasn't
-    # been reserved yet.
-    promise.job_id = job.id
-    promise.save!
-
-    evh = params['p_event']
-    if evh
-      event, klass, subject_id, operation = evh.values_at('event', 'klass',
-                                                          'id', 'operation')
-      if event
-        event.promise_id = promise.id
-        event.save!
-      else
-        event = Marty::Event.
-                create!(promise_id: promise.id,
-                        klass:      klass,
-                        subject_id: subject_id,
-                        enum_event_operation: operation)
-      end
-    end
-    Marty::PromiseProxy.new(promise.id, timeout, attr)
-  end
-end
-
-class Delorean::Engine
-  def background_eval(node, params, attrs, event = {})
-    raise 'background_eval bad params' unless params.is_a?(Hash)
-
-    params['p_event'] = event.each_with_object({}) do |(k, v), h|
-      h[k.to_s] = v
-    end unless event.empty?
-    nc = Delorean::BaseModule::NodeCall.new({}, self, node, params)
-    # start the background promise
-    nc | attrs
-  end
-end
-
 class Marty::PromiseJob < Struct.new(:promise,
                                      :title,
                                      :sname,
@@ -141,12 +46,15 @@ class Marty::PromiseJob < Struct.new(:promise,
       # log "ERR- #{Process.pid} #{promise.id} #{Time.now.to_f} #{exc}"
     end
     promise.set_result(res)
+    process_hook(res)
+  end
 
-    begin
-      hook.run(params: params, result: res) if hook
-    rescue StandardError => exc
+  def process_hook(res)
+      return unless hook
+
+      hook.run(params: params, result: res)
+  rescue StandardError => exc
       Marty::Util.logger.error "promise hook failed: #{exc}"
-    end
   end
 
   def max_attempts

data/lib/marty/promise_ruby_job.rb

@@ -0,0 +1,47 @@
+class Marty::PromiseRubyJob < Struct.new(:promise,
+                                         :title,
+                                         :module_name,
+                                         :method_name,
+                                         :method_args,
+                                         :hook,
+                                        )
+
+  def enqueue(job)
+    config = Rails.configuration.marty
+    hooks = config.promise_job_enqueue_hooks
+
+    return if hooks.blank?
+
+    hooks.each do |hook|
+      hook.call(job)
+    end
+  end
+
+  def perform
+    promise.set_start
+
+    begin
+      Mcfly.whodunnit = promise.user
+
+      mod = module_name.constantize
+      res = { 'result' => mod.send(method_name, *method_args) }
+    rescue StandardError => exc
+      res = ::Marty::Promise.exception_to_result(promise: promise, exception: exc)
+    end
+
+    promise.set_result(res)
+    process_hook(res)
+  end
+
+  def process_hook(res)
+    return unless hook
+
+    hook.run(params: method_args, result: res)
+  rescue StandardError => exc
+    Marty::Util.logger.error "promise hook failed: #{exc}"
+  end
+
+  def max_attempts
+    1
+  end
+end

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = '2.6.4'
+  VERSION = '2.6.5'
 end

data/spec/dummy/app/components/gemini/loan_program_view.rb

@@ -4,7 +4,8 @@ class Gemini::LoanProgramView < Marty::GridAppendOnly
   has_marty_permissions create: :dev,
                         read:   :any,
                         update: :dev,
-                        delete: :dev
+                        delete: :dev,
+                        test_access: :admin
 
   def configure(c)
     super
@@ -22,7 +23,27 @@ class Gemini::LoanProgramView < Marty::GridAppendOnly
     c.store_config.merge!({sorters:  [{property: :name, direction: 'ASC'}]})
   end
 
+  client_class do |c|
+    c.netzke_on_test_access = l(<<-JS)
+        function() {
+           this.server.testAccess({})
+        }
+    JS
+  end
+
+  def default_bbar
+     super + [:test_access]
+  end
+
+  action :test_access do |a|
+    a.text    = a.tooltip = 'Test Access'
+  end
+
   attribute :enum_state do |c|
     enum_column(c, Gemini::EnumState)
   end
+
+  endpoint :test_access do |c|
+    client.netzke_notify 'You have admin access'
+  end
 end

data/spec/dummy/app/models/gemini/bud_category.rb

@@ -3,5 +3,21 @@ module Gemini
     self.table_name = 'gemini_bud_categories'
     has_mcfly append_only: true
     mcfly_validates_uniqueness_of :name
+
+    def self.create_from_promise_keyword_attrs(name:, group_id:)
+      create!(name: name, group_id: group_id).id
+    end
+
+    def self.create_from_promise_regular_attrs(name, group_id)
+      create!(name: name, group_id: group_id).id
+    end
+
+    def self.create_from_promise_mixed_attrs(name, group_id:)
+      create!(name: name, group_id: group_id).id
+    end
+
+    def self.create_from_promise_error
+      raise 'Something went wrong'
+    end
   end
 end

data/spec/dummy/lib/gemini/promise_hook/test_hook.rb

@@ -0,0 +1,9 @@
+module Gemini
+  module PromiseHook
+    module TestHook
+      def self.run(opts)
+        Marty::Logger.log('TestHook', 'was called')
+      end
+    end
+  end
+end

data/spec/features/endpoint_access.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+feature 'Endpoint access', js: true do
+  before do
+    populate_test_users
+  end
+
+  context 'as admin' do
+    before do
+      log_in_as('admin1')
+      wait_for_ajax
+    end
+
+    it 'can access test_access endpoint' do
+      press('Pricing Config.')
+      press('Loan Programs')
+      press('Test Access')
+      wait_for_ajax
+      expect(page).to have_content 'You have admin access'
+    end
+  end
+
+  context 'as dev' do
+    before do
+      log_in_as('dev1')
+      wait_for_ajax
+    end
+
+    it 'can not access test_access endpoint' do
+      press('Pricing Config.')
+      press('Loan Programs')
+      press('Test Access')
+      wait_for_ajax
+      expect(page).to have_content 'Permission Denied'
+    end
+  end
+end

data/spec/features/jobs_dashboard_spec.rb

@@ -6,14 +6,20 @@ describe 'Jobs Dashboard', type: :feature, js: true, capybara: true do
                                     firstname: 'other',
                                     lastname: 'other',
                                     active: true)
-    Marty::Promise.create title: 'Test Job 1',
+    Marty::Promise.create!(
+      title: 'Test Job 1',
       user: Marty::User.find_by(login: 'marty'),
       cformat: 'csv',
-      start_dt: Time.now
-    Marty::Promise.create title: 'Test Job 2',
+      start_dt: Time.now,
+      promise_type: 'delorean'
+    )
+    Marty::Promise.create!(
+      title: 'Test Job 2',
       user: other_user,
       cformat: 'csv',
-      start_dt: Time.now
+      start_dt: Time.now,
+      promise_type: 'delorean'
+    )
 
     visit '/'
     all 'span', text: 'Sign in', minimum: 1

data/spec/lib/mcfly_model_spec.rb

@@ -194,8 +194,9 @@ describe 'McflyModel' do
                                                     1, 2)
         end
     end
-    # x time should be 30x or more than y time
-    expect(x.real / y.real).to be > 30
+    # x time should be 25x or more than y time
+    # Used to be 30x, but 30x sometimes fails on CI
+    expect(x.real / y.real).to be > 25
   end
 end
 end

data/spec/models/promise_spec.rb

@@ -28,6 +28,7 @@ describe Marty::Promise, slow: true do
   end
 
   after(:each) do
+    Marty::Log.delete_all
     Marty::Promise.where('parent_id IS NULL').destroy_all
     Timecop.return
   end
@@ -60,4 +61,149 @@ describe Marty::Promise, slow: true do
     expect(Marty::VwPromise.live_search('marty').size).to eq(10)
     expect(Marty::VwPromise.live_search('Admin').size).to eq(10)
   end
+
+  describe 'delorean' do
+    it 'processes result' do
+      expect(Marty::Promise.where(title: 'PromiseB').exists?).to be false
+
+      engine = Marty::ScriptSet.new.get_engine(NAME_B)
+      engine.background_eval(
+        'Y',
+        {
+          'p_title' => NAME_B,
+          'p_hook' => Gemini::PromiseHook::TestHook
+        },
+        ['result']
+      )
+
+      promise = Marty::Promise.find_by(title: 'PromiseB')
+      promise.wait_for_result(Marty::Promise::DEFAULT_PROMISE_TIMEOUT)
+      promise.reload
+
+      expected = [{ 'a' => 1, 'b' => 1 }, { 'a' => 2, 'b' => 4 }, { 'a' => 3, 'b' => 9 }]
+      expect(promise.status).to be true
+      expect(promise.promise_type).to eq 'delorean'
+      expect(promise.result['error']).to be nil
+      expect(promise.result['result']).to eq expected
+
+      sleep 0.1 # Wait while hooks are executed after Promise was updated
+      log = Marty::Log.find_by(message_type: 'TestHook')
+      expect(log.message).to eq 'was called'
+    end
+
+    it 'fails on exception' do
+      expect(Marty::Promise.where(title: 'PromiseJ').exists?).to be false
+
+      engine = Marty::ScriptSet.new.get_engine(NAME_J)
+      engine.background_eval('FAILER', { 'p_title' => NAME_J }, ['a'])
+
+      promise = Marty::Promise.find_by(title: 'PromiseJ')
+      promise.wait_for_result(Marty::Promise::DEFAULT_PROMISE_TIMEOUT)
+      promise.reload
+
+      expect(promise.status).to be false
+      expect(promise.promise_type).to eq 'delorean'
+      expect(promise.result['error']).to eq 'I had an error'
+    end
+  end
+
+  describe 'ruby' do
+    let(:user) { Marty::User.find_by(login: 'marty') }
+
+    it 'processes result with regular attrs' do
+      Marty::Promises::Ruby::Create.call(
+        module_name: 'Gemini::BudCategory',
+        method_name: 'create_from_promise_regular_attrs',
+        method_args: ['test name', 1],
+        params: {
+          p_title: 'test_title',
+          _user_id: user.id,
+          p_hook: Gemini::PromiseHook::TestHook
+        }
+      )
+
+      promise = Marty::Promise.where(promise_type: 'ruby').last
+      promise.wait_for_result(Marty::Promise::DEFAULT_PROMISE_TIMEOUT)
+
+      promise.reload
+
+      bud_category = Gemini::BudCategory.order(:id).last
+      expect(bud_category.name).to eq 'test name'
+
+      sleep 0.1 # Wait while hooks are executed after Promise was updated
+      log = Marty::Log.find_by(message_type: 'TestHook')
+
+      expect(promise.status).to be true
+      expect(promise.promise_type).to eq 'ruby'
+      expect(promise.result['result']).to eq bud_category.id
+      expect(log.message).to eq 'was called'
+    end
+
+    it 'processes result with keyword attrs' do
+      Marty::Promises::Ruby::Create.call(
+        module_name: 'Gemini::BudCategory',
+        method_name: 'create_from_promise_keyword_attrs',
+        method_args: [group_id: 1, name: 'test name 2'],
+        params: {
+          _user_id: user.id,
+        }
+      )
+
+      promise = Marty::Promise.where(promise_type: 'ruby').last
+      promise.wait_for_result(Marty::Promise::DEFAULT_PROMISE_TIMEOUT)
+
+      promise.reload
+
+      bud_category = Gemini::BudCategory.order(:id).last
+      expect(bud_category.name).to eq 'test name 2'
+
+      expect(promise.status).to be true
+      expect(promise.promise_type).to eq 'ruby'
+      expect(promise.result['result']).to eq bud_category.id
+    end
+
+    it 'processes result with mixed attrs' do
+      Marty::Promises::Ruby::Create.call(
+        module_name: 'Gemini::BudCategory',
+        method_name: 'create_from_promise_mixed_attrs',
+        method_args: ['test name 3', { group_id: 1 }],
+        params: {
+          _user_id: user.id,
+        }
+      )
+
+      promise = Marty::Promise.where(promise_type: 'ruby').last
+      promise.wait_for_result(Marty::Promise::DEFAULT_PROMISE_TIMEOUT)
+
+      promise.reload
+
+      bud_category = Gemini::BudCategory.order(:id).last
+      expect(bud_category.name).to eq 'test name 3'
+
+      expect(promise.status).to be true
+      expect(promise.promise_type).to eq 'ruby'
+      expect(promise.result['result']).to eq bud_category.id
+    end
+
+    it 'fails on exception' do
+      Marty::Promises::Ruby::Create.call(
+        module_name: 'Gemini::BudCategory',
+        method_name: 'create_from_promise_error',
+        method_args: [],
+        params: {
+          _user_id: user.id,
+        }
+      )
+
+      promise = Marty::Promise.where(promise_type: 'ruby').last
+      promise.wait_for_result(Marty::Promise::DEFAULT_PROMISE_TIMEOUT)
+
+      promise.reload
+
+      expect(promise.status).to be false
+      expect(promise.promise_type).to eq 'ruby'
+      expect(promise.result['error']).to eq 'Something went wrong'
+      expect(promise.result['backtrace']).to_not be_empty
+    end
+  end
 end

data/spec/support/components/netzke_grid.rb

@@ -150,7 +150,7 @@ module Marty; module RSpec; module Components
     def select_row_range(st, en)
       resid = run_js(<<-JS, 10.0)
           #{ext_var(grid, 'grid')}
-          grid.getSelectionModel().selectRange(#{st-1}, #{en-1});
+          grid.getSelectionModel().selectRange(#{st - 1}, #{en - 1});
         JS
       wait_for_ajax
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 2.6.4
+  version: 2.6.5
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-16 00:00:00.000000000 Z
+date: 2019-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -311,6 +311,7 @@ files:
 - app/models/marty/delorean_rule.rb
 - app/models/marty/enum.rb
 - app/models/marty/enum_event_operation.rb
+- app/models/marty/enum_promise_type.rb
 - app/models/marty/event.rb
 - app/models/marty/grid_index_boolean.rb
 - app/models/marty/grid_index_int4range.rb
@@ -332,6 +333,10 @@ files:
 - app/models/marty/user.rb
 - app/models/marty/user_role.rb
 - app/models/marty/vw_promise.rb
+- app/services/marty/promises/delorean.rb
+- app/services/marty/promises/delorean/create.rb
+- app/services/marty/promises/ruby.rb
+- app/services/marty/promises/ruby/create.rb
 - app/views/layouts/marty/application.html.erb
 - app/views/marty/diagnostic/diag.html.erb
 - app/views/marty/diagnostic/op.html.erb
@@ -381,6 +386,8 @@ files:
 - db/migrate/411_create_vw_promises.rb
 - db/migrate/500_add_api_class_to_marty_api_config.rb
 - db/migrate/501_create_dg_plpgsql_v1_fns.rb
+- db/migrate/502_add_promise_type_enum.rb
+- db/migrate/503_add_promise_type_to_promises.rb
 - db/seeds.rb
 - db/sql/lookup_grid_distinct_v1.sql
 - db/sql/query_grid_dir_v1.sql
@@ -411,6 +418,7 @@ files:
 - lib/marty/permissions.rb
 - lib/marty/promise_job.rb
 - lib/marty/promise_proxy.rb
+- lib/marty/promise_ruby_job.rb
 - lib/marty/railtie.rb
 - lib/marty/relation.rb
 - lib/marty/rpc_call.rb
@@ -537,6 +545,7 @@ files:
 - spec/dummy/lib/assets/.gitkeep
 - spec/dummy/lib/class_list.rb
 - spec/dummy/lib/gemini/my_rule_script_set.rb
+- spec/dummy/lib/gemini/promise_hook/test_hook.rb
 - spec/dummy/lib/gemini/xyz_rule_script_set.rb
 - spec/dummy/log/.gitkeep
 - spec/dummy/public/400.html
@@ -1551,6 +1560,7 @@ files:
 - spec/dummy/tmp/.gitkeep
 - spec/features/auth_app_spec.rb
 - spec/features/data_import_spec.rb
+- spec/features/endpoint_access.rb
 - spec/features/enum_spec.rb
 - spec/features/javascripts/job_dashboard_live_search.js.coffee
 - spec/features/javascripts/login.js.coffee