async_cache 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 52981fb455f8efb0f4995d5f14062b3fa0a5ff9e
+  data.tar.gz: 9c0a23d586fdb1fed9741112a1a2f226ce72aa40
+SHA512:
+  metadata.gz: 37a1491c788a2e71b575b8c3124b52089c394090daed0838787d8c83d885c5c140d0769ba2b54349198c0a87d0e8dabd2b8fa847af392262f8e6b8b48e9ab625
+  data.tar.gz: c0c13544a791f15c1a942aa91d88b88099d8748b6de1b0519342b795ca6f634335aefdd76bfbe3cb2f14ae5bcef168a91c7782ee65633cfe0dc00d3eb3b53df1

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'rspec-core',         '~> 3.2.3'
+gem 'rspec-expectations', '~> 3.2.1'
+gem 'rspec-mocks',        '~> 3.2.1'
+gem 'pry', :require => false

data/Gemfile.lock

@@ -0,0 +1,174 @@
+PATH
+  remote: .
+  specs:
+    async_cache (0.0.1)
+      sourcify (~> 0.5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (4.2.4)
+      actionpack (= 4.2.4)
+      actionview (= 4.2.4)
+      activejob (= 4.2.4)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+    actionpack (4.2.4)
+      actionview (= 4.2.4)
+      activesupport (= 4.2.4)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (4.2.4)
+      activesupport (= 4.2.4)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    activejob (4.2.4)
+      activesupport (= 4.2.4)
+      globalid (>= 0.3.0)
+    activemodel (4.2.4)
+      activesupport (= 4.2.4)
+      builder (~> 3.1)
+    activerecord (4.2.4)
+      activemodel (= 4.2.4)
+      activesupport (= 4.2.4)
+      arel (~> 6.0)
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.3)
+    builder (3.2.2)
+    celluloid (0.17.2)
+      celluloid-essentials
+      celluloid-extras
+      celluloid-fsm
+      celluloid-pool
+      celluloid-supervision
+      timers (>= 4.1.1)
+    celluloid-essentials (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-extras (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-fsm (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-pool (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-supervision (0.20.5)
+      timers (>= 4.1.1)
+    coderay (1.1.0)
+    connection_pool (2.2.0)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    file-tail (1.1.0)
+      tins (~> 1.0)
+    globalid (0.3.6)
+      activesupport (>= 4.1.0)
+    hitimes (1.2.3)
+    i18n (0.7.0)
+    json (1.8.3)
+    loofah (2.0.3)
+      nokogiri (>= 1.5.9)
+    mail (2.6.3)
+      mime-types (>= 1.16, < 3)
+    method_source (0.8.2)
+    mime-types (2.6.2)
+    mini_portile (0.6.2)
+    minitest (5.8.2)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.6.4)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails (4.2.4)
+      actionmailer (= 4.2.4)
+      actionpack (= 4.2.4)
+      actionview (= 4.2.4)
+      activejob (= 4.2.4)
+      activemodel (= 4.2.4)
+      activerecord (= 4.2.4)
+      activesupport (= 4.2.4)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.2.4)
+      sprockets-rails
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.7)
+      activesupport (>= 4.2.0.beta, < 5.0)
+      nokogiri (~> 1.6.0)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.2)
+      loofah (~> 2.0)
+    railties (4.2.4)
+      actionpack (= 4.2.4)
+      activesupport (= 4.2.4)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.4.2)
+    redis (3.2.1)
+    redis-namespace (1.5.2)
+      redis (~> 3.0, >= 3.0.4)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    ruby2ruby (2.2.0)
+      ruby_parser (~> 3.1)
+      sexp_processor (~> 4.0)
+    ruby_parser (3.7.2)
+      sexp_processor (~> 4.1)
+    sexp_processor (4.6.0)
+    sidekiq (3.5.2)
+      celluloid (~> 0.17.2)
+      connection_pool (~> 2.2, >= 2.2.0)
+      json (~> 1.0)
+      redis (~> 3.2, >= 3.2.1)
+      redis-namespace (~> 1.5, >= 1.5.2)
+    slop (3.6.0)
+    sourcify (0.5.0)
+      file-tail (>= 1.0.5)
+      ruby2ruby (>= 1.2.5)
+      ruby_parser (>= 2.0.5)
+      sexp_processor (>= 3.0.5)
+    sprockets (3.4.0)
+      rack (> 1, < 3)
+    sprockets-rails (2.3.3)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (>= 2.8, < 4.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    timers (4.1.1)
+      hitimes
+    tins (1.8.1)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  async_cache!
+  pry
+  rails (~> 4.2.4)
+  rspec-core (~> 3.2.3)
+  rspec-expectations (~> 3.2.1)
+  rspec-mocks (~> 3.2.1)
+  sidekiq (~> 3.5.2)
+
+BUNDLED WITH
+   1.10.6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Everlane Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# async_cache
+
+Caching is great, but having to block your app while you refresh the cache isn't so great, especially when it takes a long time to regenerate that cache entry.
+
+This outlines a strategy and provides a Rails-focused implementation for asynchronously refreshing caches while serving the stale version to users to maintain responsiveness.
+
+## Usage
+
+Add the gem to your Gemfile:
+
+```ruby
+gem 'async_cache'
+```
+
+Then set up a store and fetch from it:
+
+```ruby
+# Storing entries in `Rails.cache` and enqueueing via ActiveJob
+# (a Sidekiq worker is also available with additional
+# deduplication features).
+async_cache = AsyncCache::Store.new(
+  backend: Rails.cache,
+  worker:  :active_job
+)
+
+# Then use it to do some heavy lifting asychronously
+id      = params[:id]
+key     = "big_model/#{id}"
+version = BigModel.where(:id => id).pluck(:updated_at).first
+
+async_cache.fetch(key, version, arguments: [id]) do |id|
+  BigModel.find(id).to_json
+end
+```
+
+## Strategy
+
+Async-cache follows a straightforward strategy for determining which action to take when a cache entry is fetched:
+
+- If no entry is present it *synchronously* generates the entry, writes it to the cache, and returns it.
+- If an old version of the entry is present it enqueues an asynchronous job to refresh the entry and returns the old version.
+- If an up-to-date version of the entry is present it serves that.
+
+The implementation includes a few nuances to the strategy: such as checking if workers are running and allowing clients to specify that it should always synchronously-regenerate (useful in things like CMSes where you always want to immediately render the latest version to the user editing it).
+
+### Cache Structure
+
+Async-caching requires a different cache structure than traditional caching.
+
+In traditional caching—here using Rails idioms—the cache for the model "Thing" would look like the following:
+
+- A cache key, such as `things/123-20151210063911000000000`, where the key is comprised of the name of the model, the ID of the instance in question, and the last-modified time (`updated_at`) as an integer
+- A cache value containing the actual rendered data for that model instance
+
+In async-caching the cache must be comprised of three parts:
+
+- A cache locator, such as `things/123`
+- A version, such as `20151210063911000000000` (using the last-modified time works perfectly for this)
+- The cache value
+
+The locator must be constant in async-caching so that we can always retrieve a cache record (version and value) for the given locator. The cache record is then not just a value, but also has the metadata of the version which describes which version-of-the-locator the value applies to. By having this version metadata we're able to determine whether the cache is up-to-date or out-of-date.
+
+##### Example
+
+The following is a simplified example of how values would be cached in Rails in the traditional and async structures:
+
+```ruby
+value = compute_some_expensive_value
+
+# Traditional
+key = "things/#{thing.id}-#{thing.updated_at.to_i}"
+
+Rails.cache.write key, value
+
+# Async
+locator = "things/#{thing.id}"
+version = thing.updated_at.to_i
+
+Rails.cache.write key, [version, value]
+```
+
+## License
+
+Released under the MIT license, see [LICENSE](LICENSE) for details.

data/async_cache.gemspec

@@ -0,0 +1,23 @@
+lib = File.join File.dirname(__FILE__), 'lib'
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'async_cache/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'async_cache'
+  s.version  = AsyncCache::VERSION
+  s.authors  = ['Adam Derewecki',      'Dirk Gadsden']
+  s.email    = ['derewecki@gmail.com', 'dirk@esherido.com']
+  s.summary  = 'Pattern and library for implementing asynchronous caching'
+  s.homepage = 'https://github.com/Everlane/async_cache'
+  s.license  = 'MIT'
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_dependency 'sourcify', '~> 0.5.0'
+
+  s.add_development_dependency 'rails',   '~> 4.2.4'
+  s.add_development_dependency 'sidekiq', '~> 3.5.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+end

data/lib/async_cache/store.rb

@@ -0,0 +1,118 @@
+module AsyncCache
+  class Store
+    attr_accessor :backend, :worker_klass
+
+    def initialize(opts = {})
+      @worker_klass =
+        if opts[:worker_klass]
+          opts[:worker_klass]
+        elsif opts[:worker]
+          AsyncCache::Workers.worker_for_name opts[:worker]
+        else
+          raise ArgumentError, 'Must have a :worker_klass or :worker option'
+        end
+
+      @backend = opts[:backend] || AsyncCache.backend
+    end
+
+    def fetch(locator, version, options = {}, &block)
+      options = options.dup  # Duplicate to avoid side effects
+      version = version.to_i # Versions must *always* be convertible to integers
+
+      # Expires-in must be an integer if present, nil if not
+      expires_in = options[:expires_in] ? options[:expires_in].to_i : nil
+
+      block_arguments = check_arguments(options.delete(:arguments) || [])
+
+      # Serialize arguments into the full cache key
+      key = ActiveSupport::Cache.expand_cache_key Array.wrap(locator) + block_arguments
+
+      cached_data, cached_version = @backend.read key
+
+      strategy = determine_strategy(
+        :has_cached_data   => !!cached_data,
+        :needs_regen       => version > (cached_version || 0),
+        :synchronous_regen => options[:synchronous_regen]
+      )
+
+      context = {
+        :key        => key,
+        :version    => version,
+        :expires_in => expires_in,
+        :block      => block,
+        :arguments  => block_arguments
+      }
+
+      case strategy
+      when :generate
+        return generate_and_cache context
+
+      when :enqueue
+        enqueue_generation context
+        return cached_data
+
+      when :current
+        return cached_data
+      end
+    end
+
+    def determine_strategy(has_cached_data:, needs_regen:, synchronous_regen:)
+      case
+      when !has_cached_data
+        # Not present at all
+        :generate
+      when needs_regen && synchronous_regen
+        # Caller has indicated we should synchronously regenerate
+        :generate
+      when needs_regen && !worker_klass.has_workers?
+        # No workers available to regnerate, so do it ourselves; we'll log a
+        # warning message that we can alert on
+        AsyncCache.logger.warn "No workers running to handle AsyncCache jobs"
+        :generate
+      when needs_regen
+        :enqueue
+      else
+        :current
+      end
+    end
+
+    def generate_and_cache(key:, version:, expires_in:, block:, arguments:)
+      # Mimic the destruction-of-scope behavior of the worker in development
+      # so it will *fail* for developers if they try to depend upon scope
+      block = eval(block.to_source)
+
+      data = block.call(*arguments)
+
+      entry = [data, version]
+      @backend.write key, entry, :expires_in => expires_in
+
+      return data
+    end
+
+    def enqueue_generation(key:, version:, expires_in:, block:, arguments:)
+      worker_klass.enqueue_async_job(
+        key:        key,
+        version:    version,
+        expires_in: expires_in,
+        block:      block.to_source,
+        arguments:  arguments
+      )
+    end
+
+    private
+
+      # Ensure the arguments are primitives
+      def check_arguments arguments
+        arguments.each_with_index do |argument, index|
+          next if argument.is_a? Numeric
+          next if argument.is_a? String
+          next if argument.is_a? Symbol
+
+          raise ArgumentError, "Cannot send complex data for block argument #{index + 1}: #{argument.class.name}"
+        end
+
+        arguments
+      end
+
+  end # class Store
+end # class AsyncCache

data/lib/async_cache/version.rb

@@ -0,0 +1,3 @@
+module AsyncCache
+  VERSION = '0.0.1'
+end

data/lib/async_cache/workers/active_job.rb

@@ -0,0 +1,20 @@
+require 'active_job'
+
+module AsyncCache
+  module Workers
+    class ActiveJobWorker < ActiveJob::Base
+      include Base
+
+      def self.has_workers?
+        # ActiveJob doesn't provide a way to see if worker processes are
+        # running so we just assume that they are
+        true
+      end
+
+      def self.enqueue_async_job(key:, version:, expires_in:, block:, arguments:)
+        self.perform_later key, version, expires_in, arguments, block
+      end
+
+    end # class ActiveJobWorker
+  end
+end

data/lib/async_cache/workers/base.rb

@@ -0,0 +1,51 @@
+module AsyncCache
+  module Workers
+    def self.worker_for_name(name)
+      case name
+      when :sidekiq
+        require 'async_cache/workers/sidekiq'
+        AsyncCache::Workers::SidekiqWorker
+      when :active_job
+        require 'async_cache/workers/active_job'
+        AsyncCache::Workers::ActiveJobWorker
+      else
+        raise "Worker not found: #{name.inspect}"
+      end
+    end
+
+    module Base
+      # Abstract public interface to workers that process AsyncCache jobs
+      def self.has_workers?
+        raise NotImplementedError
+      end
+
+      def self.enqueue_async_job(key:, version:, expires_in:, block:, arguments:)
+        raise NotImplementedError
+      end
+
+      # key             - String or array cache key computed by `AsyncCache`
+      # version         - Monotonically increasing integer indicating the version
+      #                   of the resource being cached
+      # expires_in      - Optional expiration to pass to the cache store
+      # block_arguments - Arguments with which to call the block
+      # block_source    - Ruby source to evaluate to produce the value
+      def perform key, version, expires_in, block_arguments, block_source
+        t0 = Time.now
+
+        _cached_data, cached_version = backend.read key
+        return unless version > (cached_version || 0)
+
+        value = [eval(block_source).call(*block_arguments), version]
+
+        backend.write key, value, :expires_in => expires_in
+      end
+
+      private
+
+      def backend
+        AsyncCache.backend
+      end
+
+    end # module Base
+  end
+end

data/lib/async_cache/workers/sidekiq.rb

@@ -0,0 +1,34 @@
+require 'sidekiq'
+require 'sidekiq/api'
+
+module AsyncCache
+  module Workers
+    class SidekiqWorker
+      include Base
+      include Sidekiq::Worker
+
+      # Only allow one job per set of arguments to ever be in the queue
+      sidekiq_options :unique => :until_executed
+
+      # Use the Sidekiq API to see if there are worker processes available to
+      # handle the async cache jobs queue.
+      def self.has_workers?
+        target_queue = self.sidekiq_options['queue'].to_s
+
+        processes = Sidekiq::ProcessSet.new.to_a
+        queues_being_processed = processes.flat_map { |p| p['queues'] }
+
+        if queues_being_processed.include? target_queue
+          true
+        else
+          false
+        end
+      end
+
+      def self.enqueue_async_job(key:, version:, expires_in:, block:, arguments:)
+        self.perform_async key, version, expires_in, arguments, block
+      end
+
+    end # class SidekiqWorker
+  end
+end

data/lib/async_cache.rb

@@ -0,0 +1,23 @@
+require 'sourcify'
+
+module AsyncCache
+  class << self
+    def backend
+      @backend || Rails.cache
+    end
+    def backend=(backend)
+      @backend = backend
+    end
+
+    def logger
+      @logger || Rails.logger
+    end
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+end
+
+require 'async_cache/version'
+require 'async_cache/store'
+require 'async_cache/workers/base'

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+
+require 'rails'
+require 'sidekiq'
+require 'sidekiq/testing'
+
+Sidekiq::Testing.inline!
+Rails.cache  = ActiveSupport::Cache::MemoryStore.new
+Rails.logger = Logger.new($stdout).tap { |log| log.level = Logger::ERROR }
+
+require 'async_cache'

data/spec/store_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'async_cache/workers/sidekiq'
+
+describe AsyncCache::Store do
+
+  subject do
+    AsyncCache::Store.new(
+      backend: Rails.cache,
+      worker:  :sidekiq
+    )
+  end
+
+  context 'caching' do
+    def stub_not_present(key)
+      expect(Rails.cache).to receive(:read).with(key).and_return(nil)
+    end
+
+    def stub_present(key, value)
+      expect(Rails.cache).to receive(:read).with(key).and_return([value, 0])
+    end
+
+    before(:each) do
+      Rails.cache.clear
+
+      @key = 'a key'
+    end
+
+    it "synchronously calls #fetch if entry isn't present" do
+      stub_not_present @key
+
+      version    = Time.now.to_i
+      expires_in = 1.minute
+
+      # Expect another synchronous call with a block to compute the value
+      expect(Rails.cache).to receive(:write).with(@key, ['something', version], {:expires_in => expires_in}).and_call_original
+
+      fetched_value = subject.fetch(@key, version, :expires_in => expires_in) { 'something' }
+
+      expect(fetched_value).to eql 'something'
+    end
+
+    it 'returns the stale value and enqueues the worker if entry is present and timestamp is changed' do
+      # It will try to check that workers are present, so we need to make that
+      # check be a no-op
+      allow(subject.worker_klass).to receive(:has_workers?).and_return(true)
+
+      old_value  = 'old!'
+      timestamp  = Time.now
+      expires_in = 10.days.to_i
+      arguments  = [1]
+
+      # Cache key is composed of *both* the key and the arguments given to the
+      # block since those arguments determine the output of the block
+      cache_key = ActiveSupport::Cache.expand_cache_key([@key] + arguments)
+
+      stub_present cache_key, 'old!'
+
+      # Expecting it to call the worker with the block to compute the new value
+      expect(subject.worker_klass).to receive(:enqueue_async_job).with(
+        key:        cache_key,
+        version:    timestamp.to_i,
+        expires_in: expires_in,
+        block:      anything,
+        arguments:  arguments
+      ) do |opts|
+        block_source    = opts[:block]
+        block_arguments = opts[:arguments]
+
+        # Check the the block behaves correctly
+        expect(eval(block_source).call(*block_arguments)).to eql 2
+      end
+
+      fetched_value = subject.fetch(@key, timestamp, :expires_in => expires_in, :arguments => arguments) do |private_argument|
+        private_argument * 2
+      end
+
+      # Check that it immediately returns the stale value
+      expect(fetched_value).to eql old_value
+    end
+
+    it "returns the current value if timestamp isn't changed" do
+      stub_present @key, 'value'
+
+      timestamp = 0 # `stub_present` returns a timestamp of 0
+
+      expect(subject.fetch(@key, timestamp, :expires_in => 1.minute) { 'bad!' }).to eql 'value'
+    end
+
+  end # context caching
+
+  describe '#determine_strategy' do
+    it 'always generates when no data is cached' do
+      # Combinations of needs-regen and synchronous-regen arguments
+      combos = [
+        [true, true],
+        [true, false],
+        [false, false],
+        [false, true]
+      ]
+
+      combos.each do |(needs_regen, synchronous_regen)|
+        expect(
+          subject.determine_strategy(
+            has_cached_data:   false,
+            needs_regen:       needs_regen,
+            synchronous_regen: synchronous_regen
+          )
+        ).to eql :generate
+      end
+    end
+
+    context 'when needing regeneration' do
+      let(:has_cached_data) { true }
+      let(:needs_regen)     { true }
+
+      it 'generates when told to synchronously-regenerate' do
+        expect(
+          subject.determine_strategy(
+            has_cached_data:   has_cached_data,
+            needs_regen:       needs_regen,
+            synchronous_regen: true
+          )
+        ).to eql :generate
+      end
+
+      it 'enqueues when not told to synchronously-regenerate' do
+        allow(subject.worker_klass).to receive(:has_workers?).and_return(true)
+
+        expect(
+          subject.determine_strategy(
+            has_cached_data:   has_cached_data,
+            needs_regen:       needs_regen,
+            synchronous_regen: false
+          )
+        ).to eql :enqueue
+      end
+
+      it 'generates instead of enqueueing when workers are not available' do
+        allow(subject.worker_klass).to receive(:has_workers?).and_return(false)
+
+        expect(
+          subject.determine_strategy(
+            has_cached_data:   has_cached_data,
+            needs_regen:       needs_regen,
+            synchronous_regen: false
+          )
+        ).to eql :generate
+      end
+    end # context when needing regeneration
+
+    it "returns current value if it doesn't need regeneration" do
+      expect(
+        subject.determine_strategy(
+          has_cached_data:   true,
+          needs_regen:       false,
+          synchronous_regen: false
+        )
+      ).to eql :current
+    end
+
+  end # describe #determine_strategy
+
+end

data/spec/workers/active_job_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'async_cache/workers/active_job'
+
+describe AsyncCache::Workers::ActiveJobWorker do
+  subject do
+    AsyncCache::Workers::ActiveJobWorker
+  end
+
+  describe '::has_workers?' do
+    it 'returns true' do
+      expect(subject.send :has_workers?).to eql true
+    end
+  end
+
+  describe '::enqueue_async_job' do
+    it 'enqueues a job' do
+      key        = 'abc123'
+      version    = 456
+      expires_in = 789
+      block      = 'proc { }'
+      arguments  = []
+
+      expect(subject).to receive(:perform_later).with(key, version, expires_in, arguments, block)
+
+      subject.enqueue_async_job(
+        key:        key,
+        version:    version,
+        expires_in: expires_in,
+        block:      block,
+        arguments:  arguments
+      )
+    end
+  end
+end

data/spec/workers/base_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe AsyncCache::Workers do
+  subject do
+    AsyncCache::Workers
+  end
+
+  describe '::worker_for_name' do
+    it 'finds the Sidekiq worker' do
+      expect(subject.worker_for_name :sidekiq).to eql AsyncCache::Workers::SidekiqWorker
+    end
+
+    it 'finds the ActiveJob worker' do
+      expect(subject.worker_for_name :active_job).to eql AsyncCache::Workers::ActiveJobWorker
+    end
+  end
+end

data/spec/workers/sidekiq_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'async_cache/workers/sidekiq'
+
+describe AsyncCache::Workers::SidekiqWorker do
+  subject do
+    AsyncCache::Workers::SidekiqWorker
+  end
+
+  describe '::has_workers?' do
+    it 'returns false if no Sidekiq queues are available' do
+      allow(subject).to receive(:sidekiq_options).and_return({'queue' => 'good_queue'})
+
+      allow_any_instance_of(Sidekiq::ProcessSet).to receive(:to_a).and_return([
+        { 'queues' => ['bad_queue'] }
+      ])
+
+      expect(subject.send :has_workers?).to eql false
+    end
+  end
+
+  describe '::enqueue_async_job' do
+    it 'enqueues a job' do
+      key        = 'abc123'
+      version    = 456
+      expires_in = 789
+      block      = 'proc { }'
+      arguments  = []
+
+      expect(subject).to receive(:perform_async).with(key, version, expires_in, arguments, block)
+
+      subject.enqueue_async_job(
+        key:        key,
+        version:    version,
+        expires_in: expires_in,
+        block:      block,
+        arguments:  arguments
+      )
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: async_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Derewecki
+- Dirk Gadsden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sourcify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.4
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.2
+description: 
+email:
+- derewecki@gmail.com
+- dirk@esherido.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- async_cache.gemspec
+- lib/async_cache.rb
+- lib/async_cache/store.rb
+- lib/async_cache/version.rb
+- lib/async_cache/workers/active_job.rb
+- lib/async_cache/workers/base.rb
+- lib/async_cache/workers/sidekiq.rb
+- spec/spec_helper.rb
+- spec/store_spec.rb
+- spec/workers/active_job_spec.rb
+- spec/workers/base_spec.rb
+- spec/workers/sidekiq_spec.rb
+homepage: https://github.com/Everlane/async_cache
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Pattern and library for implementing asynchronous caching
+test_files: []