lev 6.0.0 → 7.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmVhODFiNzc4NGRkZTAxYTg5MmVjZjg5OWRlMDVlNDUwMmVlNDIyYg==
+    NjE5NzA3YmUwMzVmNTljMWZlMjE3MWMzNGEzODE4MjcyOTY5YWU5Zg==
   data.tar.gz: !binary |-
-    ZDU5YjNkMDRjYmE1N2VkYzQ1Njg5OWZjMDJlNzgyMjlmZDFiMzU1Yg==
+    OGVmOWM3NzViMDdlY2UwNTY0MDdmZTM1MGE1MWMyMTQ5NDc1OGRlOQ==
 SHA512:
   metadata.gz: !binary |-
-    NDRlMDY4Y2NjMTg2OWJlNjVjZDVjNWVmYzRlNDRiOGYyZGEwNzFmYWUwNWRm
-    YWEwODRjZjcxNTU3ZjExNTYxYWZkYzI4NDRmMjUzZDk3ZWMyN2UzMjE4MDA1
-    NDU0YmI1MDljNGNkZDlhMTI5YWUzN2ZkMGZiMjYzMjVhMzhhMzk=
+    N2E2ZTBiYTM2M2JhNDI1YmRiMmFiMDU5Y2IxMDY0N2IxMzMwMzQ2NGY1YjFi
+    M2NmOWI5YWQyZTc3ZGU3MmFkNTk3YWE2YjZiZDgzZTJmMjI3M2Y5YThjMGI1
+    OTRjMjcyNWEyNTdlZmI2MmY5NDg5MzI4YWJmNGMwZmU2MTA3MDY=
   data.tar.gz: !binary |-
-    NzJjOGNjZmEyZDJmYWQxY2U1Y2I5Yjc5Y2I3NzIxYzE3YjAxNDQ1ZjMzMjdj
-    MTJlNzRkN2U1MGU4MDM2NWRlMGYzNTlkZWI5N2UyZjc4M2RlODAxYmZmZjFj
-    YTc5MjExNjdhMzM2NWMyYTliYjNhZDA5N2RlM2Q3MDk1MjFhZTc=
+    ZDY5MGZiZGMwNzgxZDExZGE0Njk1ZTRiMDU0YzExYjNjZDRjNWI4NzJkZTdl
+    M2RjODNkNzUyMDYyNzUxNjYzZjhiYWNkZGEyOTJjY2RiMzFjOTY0MjFjNmEx
+    MGYzYzY5YzUzYjRkMDRkNDUyZmRhYjRjYTY4YjA0ZjNjMmVmZjE=

data/README.md

@@ -438,13 +438,15 @@ Routines have a `job` object and can call the following methods:
   a counter towards a total, e.g. `set_progress(67,212)`.
 * `queued!` Sets the job status to 'queued'
 * `working!` Sets the job status to 'working'
-* `completed!` Sets the job status to 'completed'
+* `succeeded!` Sets the job status to 'succeeded'
 * `failed!` Sets the job status to 'failed'
 * `killed!` Sets the job status to 'killed'
 * `save(hash)` Takes a hash of key value pairs and writes those keys and values to the job status; there are several reserved keys which cannot be used (and which will blow up if you try to use them)
 * `add_error(is_fatal, error)` takes a boolean and a Lev `Error` object and adds its data to an array of `errors` in the job status hash.
 
-All routines have such a job object.  For plain vanilla routines not run as an active job, the job calls are no-ops.  When a routine is invoked with `perform_later`, the job object actually records the jobs to a store of your choice.  The store is configured in the Lev configuration block, e.g.:
+Routine job objects also have query methods to check if a job is in a given state, e.g. `queued?`.  `completed?` and `incomplete` convenience methods are provided as well.  A job is complete if it is failed or succeeded; incomplete if neither.  All job routines start in an `unqueued` state and will only stay there if queueing had a problem.  Scope-like class methods (e.g. `BackgroundJob.queued`) are provided to return all jobs in a given state.
+
+For plain vanilla routines not run as an active job, the job calls are no-ops.  When a routine is invoked with `perform_later`, the job object actually records the jobs to a store of your choice.  The store is configured in the Lev configuration block, e.g.:
 
 ```ruby
 Lev.configure do |config|

data/lib/lev.rb

@@ -1,4 +1,5 @@
 require "action_view"
+require "active_job"
 require "transaction_isolation"
 require "transaction_retry"
 require "active_attr"
@@ -24,7 +25,6 @@ require "lev/form_builder"
 require "lev/delegate_to_routine"
 require "lev/transaction_isolation"
 
-require 'lev/active_job'
 require 'lev/memory_store'
 require 'lev/background_job'
 require 'lev/no_background_job'
@@ -47,12 +47,17 @@ module Lev
 
     def configure
       yield configuration
+      after_initialize
     end
 
     def configuration
       @configuration ||= Configuration.new
     end
 
+    def after_initialize
+      require 'lev/active_job'
+    end
+
     class Configuration
       # This HTML class is added to form fields that caused errors
       attr_accessor :form_error_class
@@ -61,6 +66,7 @@ module Lev
       attr_accessor :raise_fatal_errors
       attr_accessor :job_store
       attr_accessor :job_store_namespace
+      attr_accessor :job_class
 
       def initialize
         @form_error_class = 'error'
@@ -69,6 +75,7 @@ module Lev
         @raise_fatal_errors = false
         @job_store = Lev::MemoryStore.new
         @job_store_namespace = "lev_job"
+        @job_class = ::ActiveJob::Base
         super
       end
     end

data/lib/lev/active_job.rb

@@ -1,32 +1,33 @@
-if defined?(::ActiveJob)
-  module Lev
-    module ActiveJob
-      class Base < ::ActiveJob::Base
-        def self.perform_later(routine_class, *args, &block)
-          queue_as routine_class.active_job_queue
-          args.push(routine_class.to_s)
+module Lev
+  module ActiveJob
+    class Base < Lev.configuration.job_class
+      def self.perform_later(routine_class, *args, &block)
+        queue_as routine_class.active_job_queue
+        args.push(routine_class.to_s)
 
-          # To enable tracking of this job's status, create a new BackgroundJob object
-          # and push it on to the arguments so that in `perform` it can be peeled
-          # off and handed to the routine instance.  The BackgroundJob UUID is returned
-          # so that callers can track the status.
-          job = Lev::BackgroundJob.new
-          job.queued!
-          args.push(job.id)
+        # To enable tracking of this job's status, create a new BackgroundJob object
+        # and push it on to the arguments so that in `perform` it can be peeled
+        # off and handed to the routine instance.  The BackgroundJob UUID is returned
+        # so that callers can track the status.
+        job = Lev::BackgroundJob.create
+        args.push(job.id)
 
-          super(*args, &block)
+        # In theory we'd mark as queued right after the call to super, but this messes
+        # up when the activejob adapter runs the job right away
+        job.queued!
+        super(*args, &block)
 
-          job.id
-        end
+        job.id
+      end
+
+      def perform(*args, &block)
+        # Pop arguments added by perform_later
+        id = args.pop
+        routine_class = Kernel.const_get(args.pop)
 
-        def perform(*args, &block)
-          # Pop arguments added by perform_later
-          id = args.pop
-          routine_class = Kernel.const_get(args.pop)
+        routine_instance = routine_class.new(Lev::BackgroundJob.find!(id))
 
-          routine_instance = routine_class.new(Lev::BackgroundJob.new(id: id))
-          routine_instance.call(*args, &block)
-        end
+        routine_instance.call(*args, &block)
       end
     end
   end

data/lib/lev/background_job.rb

@@ -4,69 +4,87 @@ module Lev
   class BackgroundJob
     attr_reader :id, :status, :progress, :errors
 
+    STATE_UNQUEUED = 'unqueued'
     STATE_QUEUED = 'queued'
     STATE_WORKING = 'working'
-    STATE_COMPLETED = 'completed'
+    STATE_SUCCEEDED = 'succeeded'
     STATE_FAILED = 'failed'
     STATE_KILLED = 'killed'
     STATE_UNKNOWN = 'unknown'
 
     STATES = [
+      STATE_UNQUEUED,
       STATE_QUEUED,
       STATE_WORKING,
-      STATE_COMPLETED,
+      STATE_SUCCEEDED,
       STATE_FAILED,
       STATE_KILLED,
       STATE_UNKNOWN
     ].freeze
 
-    def initialize(attrs = {})
-      @id = attrs[:id] || attrs['id'] || SecureRandom.uuid
-      @status = attrs[:status] || attrs['status'] || STATE_UNKNOWN
-      @progress = attrs[:progress] || attrs['progress'] || 0
-      @errors = attrs[:errors] || attrs['errors'] || []
+    def self.create
+      new(status: STATE_UNQUEUED).tap do |job|
+        job.save_standard_values
+      end
+    end
 
-      set({ id: id,
-            status: status,
-            progress: progress,
-            errors: errors })
+    # Finds the job with the specified ID and returns it.  If no such ID
+    # exists in the store, returns a job with 'unknown' status and sets it
+    # in the store
+    def self.find!(id)
+      find(id) || new({id: id}).tap do |job|
+        job.save_standard_values
+      end
     end
 
+    # Finds the job with the specified ID and returns it.  If no such ID
+    # exists in the store, returns nil.
     def self.find(id)
+      raise(ArgumentError, "`id` cannot be nil") if id.nil?
+
       attrs = { id: id }
 
-      if job = fetch_and_parse(job_key(id))
-        attrs.merge!(job)
+      existing_job_attrs = fetch_and_parse(job_key(id))
+
+      if existing_job_attrs.present?
+        attrs.merge!(existing_job_attrs)
+        new(attrs)
       else
-        attrs.merge!(status: STATE_UNKNOWN)
+        nil
       end
-
-      new(attrs)
     end
 
     def self.all
-      job_ids.map { |id| find(id) }
+      job_ids.map { |id| find!(id) }
     end
 
     def set_progress(at, out_of = nil)
       progress = compute_fractional_progress(at, out_of)
-
-      data_to_set = { progress: progress }
-      data_to_set[:status] = STATE_COMPLETED if 1.0 == progress
-
-      set(data_to_set)
-
-      progress
+      set(progress: progress)
     end
 
-    (STATES - [STATE_COMPLETED]).each do |state|
+    STATES.each do |state|
       define_method("#{state}!") do
         set(status: state)
       end
+
+      define_method("#{state}?") do
+        status == state
+      end
     end
 
-    def completed!
-      set({status: STATE_COMPLETED, progress: 1.0})
+    (STATES + %w(completed incomplete)).each do |state|
+      define_singleton_method("#{state}") do
+        all.select{|job| job.send("#{state}?")}
+      end
+    end
+
+    def completed?
+      failed? || succeeded?
+    end
+
+    def incomplete?
+      !completed?
     end
 
     def add_error(error, options = { })
@@ -92,29 +110,64 @@ module Lev
       end
     end
 
+    def save_standard_values
+      set({
+        id: id,
+        status: status,
+        progress: progress,
+        errors: errors
+      })
+    end
+
     def method_missing(method_name, *args)
-      instance_variable_get("@#{method_name}") || super
+      get_dynamic_variable(method_name) || super
     end
 
     def respond_to?(method_name)
-      if method_name.match /\?$/
-        super
-      else
-        instance_variable_get("@#{method_name}").present? || super
-      end
+      has_dynamic_variable?(method_name) || super
     end
 
     protected
+
     RESERVED_KEYS = [:id, :status, :progress, :errors]
 
+    def initialize(attrs = {})
+      attrs = attrs.stringify_keys
+
+      @id = attrs['id'] || SecureRandom.uuid
+      @status = attrs['status'] || STATE_UNKNOWN
+      @progress = attrs['progress'] || 0
+      @errors = attrs['errors'] || []
+
+      attrs.each do |attr, value|
+        if !instance_variable_defined?("@#{attr}")
+          instance_variable_set("@#{attr}", attrs[attr])
+        end
+      end
+    end
+
     def set(incoming_hash)
-      incoming_hash = incoming_hash.stringify_keys
-      incoming_hash = stored.merge(incoming_hash)
-      incoming_hash.each { |k, v| instance_variable_set("@#{k}", v) }
-      self.class.store.write(job_key, incoming_hash.to_json)
+      apply_consistency_rules!(incoming_hash)
+      new_hash = stored.merge(incoming_hash)
+      new_hash.each { |k, v| instance_variable_set("@#{k}", v) }
+      self.class.store.write(job_key, new_hash.to_json)
       track_job_id
     end
 
+    def apply_consistency_rules!(hash)
+      hash.stringify_keys!
+      hash['progress'] = 1.0 if hash['status'] == 'succeeded'
+    end
+
+    def get_dynamic_variable(name)
+      return nil if !has_dynamic_variable?(name)
+      instance_variable_get("@#{name}")
+    end
+
+    def has_dynamic_variable?(name)
+      !name.match(/\?|\!/) && instance_variable_defined?("@#{name}")
+    end
+
     def self.store
       Lev.configuration.job_store
     end
@@ -157,12 +210,6 @@ module Lev
       set(key => new_value)
     end
 
-    STATES.each do |state|
-      define_method("#{state}?") do
-        status == state
-      end
-    end
-
     def compute_fractional_progress(at, out_of)
       if at.nil?
         raise IllegalArgument, "Must specify at least `at` argument to `progress` call"

data/lib/lev/handler.rb

@@ -14,28 +14,28 @@ module Lev
     end
   end
 
-  # Common methods for all handlers.  Handlers are extensions of Routines 
-  # and are responsible for taking input data from a form or other widget and 
+  # Common methods for all handlers.  Handlers are extensions of Routines
+  # and are responsible for taking input data from a form or other widget and
   # doing something with it.  See Lev::Routine for more information.
   #
   # All handlers must:
   #   2) call "lev_handler"
-  #   3) implement the 'handle' method which takes no arguments and does the 
+  #   3) implement the 'handle' method which takes no arguments and does the
   #      work the handler is charged with
-  #   4) implement the 'authorized?' method which returns true iff the 
+  #   4) implement the 'authorized?' method which returns true iff the
   #      caller is authorized to do what the handler is charged with
   #
   # Handlers may:
   #   1) implement the 'setup' method which runs before 'authorized?' and 'handle'.
-  #      This method can do anything, and will likely include setting up some 
+  #      This method can do anything, and will likely include setting up some
   #      instance objects based on the params.
   #   2) Call the class method "paramify" to declare, cast, and validate parts of
   #      the params hash. The first argument to paramify is the key in params
   #      which points to a hash of params to be paramified.  If this first argument
-  #      is unspecified (or specified as `:paramify`, a reserved symbol), the entire 
-  #      params hash will be paramified.  The block passed to paramify looks just 
+  #      is unspecified (or specified as `:paramify`, a reserved symbol), the entire
+  #      params hash will be paramified.  The block passed to paramify looks just
   #      like the guts of an ActiveAttr model.
-  #      
+  #
   #      When the incoming params includes :search => {:type, :terms, :num_results}
   #      the Handler class would look like:
   #
@@ -53,9 +53,9 @@ module Lev
   #
   #          attribute :num_results, type: Integer
   #          validates :num_results, numericality: { only_integer: true,
-  #                                            greater_than_or_equal_to: 0 }                               
+  #                                            greater_than_or_equal_to: 0 }
   #        end
-  #        
+  #
   #        def handle
   #          # By this time, if there were any errors the handler would have
   #          # already populated the errors object and returned.
@@ -81,23 +81,23 @@ module Lev
   #
   # These methods are available iff these data were supplied in the call
   # to the handler (not all handlers need all of this).  However, note that
-  # the Lev::HandleWith module supplies an easy way to call Handlers from 
+  # the Lev::HandleWith module supplies an easy way to call Handlers from
   # controllers -- when this way is used, all of the methods above are available.
   #
-  # Handler 'handle' methods don't return anything; they just set values in 
+  # Handler 'handle' methods don't return anything; they just set values in
   # the errors and results objects.  The documentation for each handler
   # should explain what the results will be and any nonstandard data required
   # to be passed in in the options.
   #
-  # In addition to the class- and instance-level "call" methods provided by 
+  # In addition to the class- and instance-level "call" methods provided by
   # Lev::Routine, Handlers have a class-level "handle" method (an alias of
   # the class-level "call" method).  The convention for handlers is that the
   # call methods take a hash of options/inputs.  The instance-level handle
   # method doesn't take any arguments since the arguments have been stored
   # as instance variables by the time the instance-level handle method is called.
-  # 
+  #
   # Example:
-  # 
+  #
   #   class MyHandler
   #     lev_handler
   #   protected
@@ -119,7 +119,7 @@ module Lev
     end
 
     module ClassMethods
-  
+
       def handle(options={})
         call(options)
       end
@@ -140,14 +140,14 @@ module Lev
           end
 
           # Attach a name to this dynamic class
-          const_set("#{group.to_s.capitalize}Paramifier", 
+          const_set("#{group.to_s.capitalize}Paramifier",
                     paramify_classes[group])
 
           paramify_classes[group].class_eval(&block)
           paramify_classes[group].group = group
         end
 
-        # Define the "#{group}_params" method to get the paramifier 
+        # Define the "#{group}_params" method to get the paramifier
         # instance wrapping the params.  Choose the subset of params
         # based on the group, choosing all params if the default group
         # is used.
@@ -155,7 +155,7 @@ module Lev
         define_method method_name.to_sym do
           if !instance_variable_get(variable_sym)
             params_subset = group == :paramify ? params : params[group]
-            instance_variable_set(variable_sym, 
+            instance_variable_set(variable_sym,
                                   self.class.paramify_classes[group].new(params_subset))
           end
           instance_variable_get(variable_sym)
@@ -187,12 +187,12 @@ module Lev
     attr_accessor :auth_error_details
 
     # This is a method required by Lev::Routine.  It enforces the steps common
-    # to all handlers.  
+    # to all handlers.
     def exec(options)
-      self.params = options.delete(:params)
-      self.request = options.delete(:request)
-      self.caller = options.delete(:caller)
-      self.options = options
+      self.params = options[:params]
+      self.request = options[:request]
+      self.caller = options[:caller]
+      self.options = options.except(:params, :request, :caller)
 
       setup
       raise Lev.configuration.security_transgression_error, auth_error_details unless authorized?
@@ -203,19 +203,19 @@ module Lev
     # Default setup implementation -- a no-op
     def setup; end
 
-    # Default authorized? implementation.  It returns true so that every 
+    # Default authorized? implementation.  It returns true so that every
     # handler realization has to make a conscious decision about who is authorized
-    # to call the handler. To help the common error of forgetting to override this 
+    # to call the handler. To help the common error of forgetting to override this
     # method in a handler instance, we provide an error message when this default
     # implementation is called.
     def authorized?
-      self.auth_error_details = 
+      self.auth_error_details =
         "Access to handlers is prevented by default.  You need to override the " +
         "'authorized?' in this handler to explicitly grant access."
       false
     end
 
-    
+
 
     # Helper method to validate paramified params and to transfer any errors
     # into the handler.

data/lib/lev/no_background_job.rb

@@ -14,7 +14,7 @@ module Lev
     end
 
     def self.method_missing(method_sym, *args, &block)
-      if Lev::BackgroundJob.new.respond_to?(method_sym)
+      if Lev::BackgroundJob.method_defined?(method_sym)
         raise NameError,
               "'#{method_sym}' is Lev::BackgroundJob query method, and those cannot be called on NoBackgroundJob"
       else

data/lib/lev/routine.rb

@@ -208,15 +208,13 @@ module Lev
         result.outputs.send(@express_output)
       end
 
-      if defined?(::ActiveJob)
-        def perform_later(*args, &block)
-          # Delegate to a subclass of Lev::Routine::ActiveJob::Base
-          Lev::ActiveJob::Base.perform_later(self, *args, &block)
-        end
+      def perform_later(*args, &block)
+        # Delegate to a subclass of Lev::Routine::ActiveJob::Base
+        Lev::ActiveJob::Base.perform_later(self, *args, &block)
+      end
 
-        def active_job_queue
-          @active_job_queue || :default
-        end
+      def active_job_queue
+        @active_job_queue || :default
       end
 
       # Called at a routine's class level to foretell which other routines will
@@ -271,6 +269,8 @@ module Lev
 
       begin
         in_transaction do
+          reset_result! if transaction_run_by?(self)
+
           catch :fatal_errors_encountered do
             if self.class.delegates_to
               run(self.class.delegates_to, *args, &block)
@@ -297,7 +297,7 @@ module Lev
         raise e
       end
 
-      job.completed! if !errors?
+      job.succeeded! if !errors?
 
       result
     end
@@ -449,6 +449,10 @@ module Lev
                              Errors.new(job, topmost_runner.class.raise_fatal_errors?))
     end
 
+    def reset_result!
+      @result = nil
+    end
+
     def outputs
       result.outputs
     end

data/lib/lev/version.rb

@@ -1,3 +1,3 @@
 module Lev
-  VERSION = "6.0.0"
+  VERSION = "7.0.0"
 end

data/spec/background_job_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'lev/active_job'
 
 describe Lev::BackgroundJob do
 
@@ -19,13 +20,13 @@ describe Lev::BackgroundJob do
 
     it 'behaves as a nice ruby object' do
       expect(job.id).to eq('123abc')
-      expect(job.status).to eq(Lev::BackgroundJob::STATE_QUEUED)
+      expect(job.status).to eq(described_class::STATE_QUEUED)
       expect(job.progress).to eq(0.0)
     end
 
     it 'is unknown when not found' do
-      foo = described_class.find('noooooo')
-      expect(foo.status).to eq(Lev::BackgroundJob::STATE_UNKNOWN)
+      foo = described_class.find!('noooooo')
+      expect(foo.status).to eq(described_class::STATE_UNKNOWN)
     end
 
     it 'uses as_json' do
@@ -33,7 +34,7 @@ describe Lev::BackgroundJob do
 
       expect(json).to eq({
         'id' => '123abc',
-        'status' => Lev::BackgroundJob::STATE_QUEUED,
+        'status' => described_class::STATE_QUEUED,
         'progress' => 0.0,
         'errors' => []
       })
@@ -43,12 +44,86 @@ describe Lev::BackgroundJob do
 
       expect(json['foo']).to eq('bar')
     end
+
+    it 'generates attributes for custom variables' do
+      job.save(foo: 'bar')
+
+      reloaded_job = Lev::BackgroundJob.find(job.id)
+
+      expect(reloaded_job.respond_to?(:foo)).to be true
+      expect(reloaded_job.foo).to eq('bar')
+    end
+
+    it 'has scopes' do
+      expect(described_class.incomplete.collect(&:id)).to include(job.id)
+
+      job.queued!
+      expect(described_class.incomplete.collect(&:id)).to include(job.id)
+      expect(described_class.queued.collect(&:id)).to include(job.id)
+
+      job.working!
+      expect(described_class.incomplete.collect(&:id)).to include(job.id)
+      expect(described_class.working.collect(&:id)).to include(job.id)
+
+      job.failed!
+      expect(described_class.incomplete.collect(&:id)).not_to include(job.id)
+      expect(described_class.failed.collect(&:id)).to include(job.id)
+
+      job.killed!
+      expect(described_class.incomplete.collect(&:id)).to include(job.id)
+      expect(described_class.killed.collect(&:id)).to include(job.id)
+
+      job.unknown!
+      expect(described_class.incomplete.collect(&:id)).to include(job.id)
+      expect(described_class.unknown.collect(&:id)).to include(job.id)
+
+      job.succeeded!
+      expect(described_class.succeeded.collect(&:id)).to include(job.id)
+      expect(described_class.incomplete.collect(&:id)).not_to include(job.id)
+      expect(described_class.succeeded.collect(&:id)).to include(job.id)
+    end
+
+    it 'has the unqueued scope' do
+      expect(described_class.unqueued.collect(&:id)).to eq []
+      unqueued_job = Lev::BackgroundJob.create
+      expect(described_class.unqueued.collect(&:id)).to include(unqueued_job.id)
+    end
   end
 
-  it 'sets progress to 100% when completed' do
-    job = Lev::BackgroundJob.new
-    job.completed!
+  it 'sets progress to 100% when succeeded' do
+    job = described_class.new
+    job.succeeded!
     expect(job.progress).to eq 1
   end
 
+  describe '.find!' do
+    let!(:job) { described_class.create }
+
+    it 'does not write to store when job exists' do
+      expect(described_class.store).to_not receive(:write)
+      found_job = described_class.find!(job.id)
+      expect(found_job.as_json).to eq(job.as_json)
+    end
+
+    it 'finds jobs that are not in the store' do
+      found_job = described_class.find!('not-a-real-id')
+      expect(found_job.as_json).to include('status' => 'unknown')
+    end
+  end
+
+  describe '.find' do
+    let!(:job) { described_class.create }
+
+    it 'finds jobs that are in the store' do
+      expect(described_class.store).to_not receive(:write)
+      found_job = described_class.find(job.id)
+      expect(found_job.as_json).to eq(job.as_json)
+    end
+
+    it 'returns nil for jobs not in the store' do
+      found_job = described_class.find('not-a-real-id')
+      expect(found_job).to be_nil
+    end
+  end
+
 end

data/spec/routine_spec.rb

@@ -116,4 +116,41 @@ describe Lev::Routine do
     end
   end
 
+  it 'does not mess up results on a transaction retry' do
+    # To get the transaction to retry, we need to raise an exception the first time
+    # through execution, after an output has been set in a nested routine and
+    # translated to the parent routine
+
+    stub_const 'NestedRoutine', Class.new
+    NestedRoutine.class_eval {
+      lev_routine
+      def exec
+        outputs[:test] = 1
+      end
+    }
+
+    stub_const 'MainRoutine', Class.new
+    MainRoutine.class_eval {
+      lev_routine
+      uses_routine NestedRoutine,
+                   translations: {outputs: {type: :verbatim}}
+
+      def exec
+        run(NestedRoutine)
+
+        @times_called ||= 0
+        @times_called += 1
+        raise(::ActiveRecord::TransactionIsolationConflict, 'hi') if @times_called == 1
+      end
+    }
+
+    # In reality, the Lev routine is the top-level transaction, but rspec has its own
+    # transactions at the top, so we have to fake that the Lev routine transaction
+    # is at the top.
+    allow(ActiveRecord::Base).to receive(:tr_in_nested_transaction?) { false }
+
+    results = MainRoutine.call
+    expect(results.outputs.test).to eq 1
+  end
+
 end

data/spec/spec_helper.rb

@@ -25,6 +25,9 @@ end
 require 'lev'
 require 'debugger'
 
+require 'transaction_retry'
+TransactionRetry.apply_activerecord_patch
+
 Dir[(File.expand_path('../support', __FILE__)) + ("/**/*.rb")].each { |f| require f }
 
 ActiveRecord::Base.establish_connection(

data/spec/statused_routines_spec.rb

@@ -32,7 +32,7 @@ RSpec.describe 'Statused Routines' do
       it 'completes the job object on completion, returning other data' do
         id = StatusedRoutine.perform_later
         job = Lev::BackgroundJob.find(id)
-        expect(job.status).to eq(Lev::BackgroundJob::STATE_COMPLETED)
+        expect(job.status).to eq(Lev::BackgroundJob::STATE_SUCCEEDED)
         expect(job.progress).to eq(1.0)
       end
     end
@@ -95,10 +95,10 @@ RSpec.describe 'Statused Routines' do
       expect(job).to be_working
     end
 
-    it 'is completed' do
-      expect(job).not_to be_completed
-      job.completed!
-      expect(job).to be_completed
+    it 'is succeeded' do
+      expect(job).not_to be_succeeded
+      job.succeeded!
+      expect(job).to be_succeeded
     end
 
     it 'is failed' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lev
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 7.0.0
 platform: ruby
 authors:
 - JP Slavinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-26 00:00:00.000000000 Z
+date: 2016-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -16,44 +16,44 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
-  name: transaction_isolation
+  name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: transaction_retry
+  name: transaction_isolation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: active_attr
+  name: transaction_retry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: active_attr
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -109,13 +109,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -123,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -137,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -151,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -165,7 +165,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: debugger
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -179,7 +179,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activejob
+  name: debugger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='