alephant-sequencer 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87eb4dd20f752ece22dbe6b54764419a159454f5
-  data.tar.gz: 11216e816528c7446d3bb79e8929f1128cdea1db
+  metadata.gz: 4af417788a323d36227f7e705f0537eacf11894e
+  data.tar.gz: a498b323f2816d4ba5e3aff2d33a7335baa9c908
 SHA512:
-  metadata.gz: 0a8bfa3ac07eda7b55546155dafb1000e26e18612d57604fc1f1cd2703edf1fe9bbca98c040b137322bd5ad7dfd3e8de48f79915cfd33187325abd3bea3832d3
-  data.tar.gz: 98837d665ded03582bf974cf48404e3c610cfc0e5c83955205f22156f119029d1be4a109fcac622c67a741784eec438abb61113d74bd22da5c19072795acf740
+  metadata.gz: 109acfd366f1111097bc8df61a5420d51874449a76bd3ba022b9c32e8b83232bc71f494979549a1bdf45b1707cadbe36043229f9637e9dcfa39ce3d183745352
+  data.tar.gz: 4de01f944436280b032af57ecb72ca623cc2753ec0b481cdf88fbcf56c9be5452bb10ddec2699a6e2b56b25385a12897b2b2cb49a828e4614881f019081397c4

data/alephant-sequencer.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'alephant/sequencer/version'
+require "alephant/sequencer/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "alephant-sequencer"
@@ -28,8 +28,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-remote"
   spec.add_development_dependency "pry-nav"
 
-  spec.add_runtime_dependency 'aws-sdk', '~> 1.0'
-  spec.add_runtime_dependency 'alephant-logger'
-  spec.add_runtime_dependency 'alephant-support'
-  spec.add_runtime_dependency 'jsonpath'
+  spec.add_runtime_dependency "aws-sdk", "~> 1.0"
+  spec.add_runtime_dependency "alephant-logger"
+  spec.add_runtime_dependency "alephant-support"
+  spec.add_runtime_dependency "jsonpath"
+  spec.add_runtime_dependency "dalli-elasticache"
 end

data/lib/alephant/sequencer/sequence_cache.rb

@@ -0,0 +1,69 @@
+require "dalli-elasticache"
+require "alephant/logger"
+
+module Alephant
+  module Sequencer
+    class SequenceCache
+      include Logger
+
+      attr_reader :config
+
+      DEFAULT_TTL  = 5
+
+      def initialize(config={})
+        @config = config
+
+        unless config_endpoint.nil?
+          @elasticache ||= ::Dalli::ElastiCache.new(config_endpoint, { :expires_in => ttl })
+          @client ||= @elasticache.client
+        else
+          logger.debug "Alephant::SequenceCache::#initialize: No config endpoint, NullClient used"
+          logger.metric "NoConfigEndpoint"
+          @client = NullClient.new
+        end
+      end
+
+      def get(key, &block)
+        begin
+          versioned_key = versioned key
+          result = @client.get versioned_key
+          logger.info "Alephant::SequenceCache#get key: #{versioned_key} - #{result ? 'hit' : 'miss'}"
+          logger.metric "GetKeyMiss" unless result
+          result ? result : set(key, block.call)
+        rescue StandardError => e
+          block.call
+        end
+      end
+
+      def set(key, value, ttl = nil)
+        value.tap { |o| @client.set(versioned(key), o, ttl) }
+      end
+
+      private
+
+      def config_endpoint
+        config["elasticache_config_endpoint"]
+      end
+
+      def ttl
+        config["elasticache_ttl"] || DEFAULT_TTL
+      end
+
+      def versioned(key)
+        [key, cache_version].compact.join("_")
+      end
+
+      def cache_version
+        config["elasticache_cache_version"]
+      end
+    end
+
+    class NullClient
+      def get(key); end
+
+      def set(key, value, ttl = nil)
+        value
+      end
+    end
+  end
+end

data/lib/alephant/sequencer/sequencer.rb

@@ -1,24 +1,25 @@
-require 'jsonpath'
-require 'alephant/logger'
+require "jsonpath"
+require "alephant/logger"
 
 module Alephant
   module Sequencer
     class Sequencer
       include Logger
-      attr_reader :ident, :jsonpath, :keep_all
+      attr_reader :ident, :jsonpath, :keep_all, :cache
 
-      def initialize(sequence_table, id, sequence_path, keep_all = true)
+      def initialize(sequence_table, opts = {})
         @sequence_table = sequence_table
 
-        @keep_all = keep_all
+        @cache    = opts[:cache]
+        @keep_all = opts[:keep_all]
+        @ident    = opts[:id]
         @exists   = exists?
-        @jsonpath = sequence_path
-        @ident    = id
+        @jsonpath = opts[:jsonpath]
         logger.info(
           "event"         => "SequencerInitialized",
           "sequenceTable" => sequence_table,
-          "jsonPath"      => sequence_path,
-          "id"            => id,
+          "jsonPath"      => @jsonpath,
+          "id"            => @ident,
           "method"        => "#{self.class}#initialize"
         )
       end
@@ -28,7 +29,9 @@ module Alephant
       end
 
       def exists?
-        @exists || @sequence_table.sequence_exists(ident)
+        @exists || cache.get(ident) do
+          @sequence_table.sequence_exists(ident)
+        end
       end
 
       def validate(msg, &block)
@@ -75,7 +78,9 @@ module Alephant
       end
 
       def get_last_seen(key = ident)
-        @sequence_table.sequence_for(key)
+        cache.get(key) do
+          @sequence_table.sequence_for(key)
+        end
       end
 
       def self.sequence_id_from(msg, path)

data/lib/alephant/sequencer/version.rb

@@ -1,5 +1,5 @@
 module Alephant
   module Sequencer
-    VERSION = "2.0.1"
+    VERSION = "3.0.0"
   end
 end

data/lib/alephant/sequencer.rb

@@ -1,15 +1,31 @@
 require "alephant/sequencer/version"
 require "alephant/sequencer/sequencer"
 require "alephant/sequencer/sequence_table"
+require "alephant/sequencer/sequence_cache"
 
 module Alephant
   module Sequencer
     @@sequence_tables = {}
 
-    def self.create(table_name, ident, jsonpath = nil, keep_all = true)
+    def self.create(table_name, opts = {})
+      defaults = {
+        :jsonpath => nil,
+        :keep_all => true,
+        :config => {}
+      }
+
+      opts = defaults.merge(opts).tap do |opts|
+        opts[:cache] = self.cache(opts[:config])
+      end
+
       @@sequence_tables[table_name] ||= SequenceTable.new(table_name)
-      Sequencer.new(@@sequence_tables[table_name], ident, jsonpath, keep_all)
+      Sequencer.new(@@sequence_tables[table_name], opts)
     end
 
+    private
+
+    def self.cache(config)
+      @cache ||= SequenceCache.new(config)
+    end
   end
 end

data/spec/sequencer_spec.rb

@@ -3,16 +3,51 @@ require "spec_helper"
 describe Alephant::Sequencer do
   let(:ident)    { :ident }
   let(:jsonpath) { "$.sequence_id" }
-
-  describe ".create(table_name, ident, jsonpath)" do
+  let(:sequence_table) { double(Alephant::Sequencer::SequenceTable) }
+  let(:keep_all) { true }
+  let(:config) { { "elasticache_config_endpoint" => "/foo" } }
+  let(:cache) { Alephant::Sequencer::SequenceCache.new(config) }
+  let(:opts) {
+    {
+      :id => ident,
+      :jsonpath => jsonpath,
+      :keep_all => keep_all,
+      :cache => cache
+    }
+  }
+
+  describe ".create" do
     it "should return a Sequencer" do
-      Alephant::Sequencer::SequenceTable
-        .any_instance
-        .stub(:create)
+      expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+      expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+      expect_any_instance_of(Alephant::Sequencer::SequenceTable).to receive(:initialize)
+      expect_any_instance_of(Alephant::Sequencer::SequenceTable).to receive(:sequence_exists)
+
+      opts = {
+        :id => ident,
+        :jsonpath => jsonpath,
+        :keep_all => keep_all,
+        :config => config
+      }
+
+      expect(subject.create(:table_name, opts)).to be_a Alephant::Sequencer::Sequencer
+    end
+
+    it "should use default opts if options not provided" do
+      expect_any_instance_of(Alephant::Sequencer::SequenceTable).to receive(:sequence_exists)
+
+      opts = {
+        :id => ident
+      }
+
+      instance = subject.create(:table_name, opts)
 
-      expect(
-        subject.create(:table_name, ident, jsonpath)
-      ).to be_a Alephant::Sequencer::Sequencer
+      expect(instance).to be_a Alephant::Sequencer::Sequencer
+      expect(instance.ident).to eq(ident)
+      expect(instance.jsonpath).to eq(nil)
+      expect(instance.keep_all).to eq(true)
+      expect(instance.cache).to be_a(Alephant::Sequencer::SequenceCache)
     end
   end
 
@@ -20,36 +55,30 @@ describe Alephant::Sequencer do
     let(:data)      { double() }
     let(:last_seen) { 42 }
 
-    def sequence_table
-      table = double()
-      table.stub(:create)
-      table.stub(:sequence_exists)
-      table.stub(:sequence_for)
-      table.stub(:update_sequence_id)
-      table.stub(:truncate!)
-      table
-    end
+    describe "#initialize" do
+      subject (:instance) {
+        described_class.new(sequence_table, opts)
+      }
 
-    describe "#initialize(opts, id)" do
       it "sets @jsonpath, @ident" do
-        subject = Alephant::Sequencer::Sequencer.new(sequence_table, ident, jsonpath)
+        expect(sequence_table).to receive(:sequence_exists)
+
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
 
-        expect(subject.jsonpath).to eq(jsonpath)
-        expect(subject.ident).to eq(ident)
+        expect(instance.jsonpath).to eq(jsonpath)
+        expect(instance.ident).to eq(ident)
+        expect(instance.keep_all).to eq(true)
       end
 
     end
 
-    describe "#validate(msg, &block)" do
-      let(:message) do
-        m = double()
-        m.stub(:body)
-        m
-      end
+    describe "#validate" do
+      let(:message) { double() }
 
       let(:an_uncalled_proc) do
         a_block = double()
-        a_block.should_not_receive(:called).with(message)
+        expect(a_block).to_not receive(:called).with(message)
 
         Proc.new do |msg|
           a_block.called(msg)
@@ -58,7 +87,7 @@ describe Alephant::Sequencer do
 
       let(:a_proc) do
         a_block = double()
-        a_block.should_receive(:called)
+        expect(a_block).to receive(:called)
 
         Proc.new do
           a_block.called
@@ -69,187 +98,236 @@ describe Alephant::Sequencer do
       let(:stubbed_seen_high) { 3 }
       let(:stubbed_seen_low)  { 1 }
 
+      subject (:instance) {
+        described_class.new(sequence_table, opts)
+      }
+
       it "should call the passed block" do
-        subject = Alephant::Sequencer::Sequencer.new(sequence_table, ident, jsonpath)
-        subject.validate(message, &a_proc)
+        expect(sequence_table).to receive(:sequence_exists)
+        expect(sequence_table).to receive(:sequence_for).with(ident)
+
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+        expect_any_instance_of(Dalli::Client).to receive(:get).twice
+        expect_any_instance_of(Dalli::Client).to receive(:set).twice
+
+        expect(message).to receive(:body)
+
+        instance.validate(message, &a_proc)
       end
 
       context "last_seen_id is nil" do
         before(:each) do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .stub(:get_last_seen)
-            .and_return(nil)
-
-          Alephant::Sequencer::Sequencer
-            .stub(:sequence_id_from)
-            .and_return(stubbed_seen_high)
+          expect_any_instance_of(described_class).to receive(:get_last_seen).and_return(nil)
+
+          expect(described_class).to receive(:sequence_id_from).and_return(stubbed_seen_high)
+
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+          expect_any_instance_of(Dalli::Client).to receive(:get)
+          expect_any_instance_of(Dalli::Client).to receive(:set)
         end
 
-        it "should not call set_last_seen(msg, last_seen_id)" do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .should_receive(:set_last_seen)
-            .with(message, nil)
+        it "should not call set_last_seen" do
+          expect_any_instance_of(described_class).to receive(:set_last_seen).with(message, nil)
 
-          subject = Alephant::Sequencer::Sequencer.new(sequence_table, ident, jsonpath)
-          subject.validate(message, &a_proc)
+          expect(sequence_table).to receive(:sequence_exists)
+
+          instance.validate(message, &a_proc)
         end
       end
 
       context "last_seen_id == sequence_id_from(msg)" do
         before(:each) do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .stub(:get_last_seen)
-            .and_return(stubbed_last_seen)
-
-          Alephant::Sequencer::Sequencer
-            .stub(:sequence_id_from)
-            .and_return(stubbed_last_seen)
+          expect_any_instance_of(described_class).to receive(:get_last_seen).and_return(stubbed_last_seen)
+
+          expect(described_class).to receive(:sequence_id_from).and_return(stubbed_last_seen)
+
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+          expect_any_instance_of(Dalli::Client).to receive(:get)
+          expect_any_instance_of(Dalli::Client).to receive(:set)
         end
 
         it "should not call set_last_seen(msg, last_seen_id)" do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .should_not_receive(:set_last_seen)
+          expect_any_instance_of(described_class).to_not receive(:set_last_seen)
 
-          subject = Alephant::Sequencer::Sequencer.new(sequence_table, ident, jsonpath)
-          subject.validate(message, &a_proc)
+          expect(sequence_table).to receive(:sequence_exists)
+
+          instance.validate(message, &a_proc)
         end
       end
 
       context "last_seen_id > sequence_id_from(msg)" do
         before(:each) do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .stub(:get_last_seen)
-            .and_return(stubbed_last_seen)
-
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .stub(:sequence_id_from)
-            .and_return(stubbed_seen_low)
+          expect_any_instance_of(described_class).to receive(:get_last_seen).and_return(stubbed_last_seen)
+
+          expect(described_class).to receive(:sequence_id_from).and_return(stubbed_seen_low)
+
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+          expect_any_instance_of(Dalli::Client).to receive(:get)
+          expect_any_instance_of(Dalli::Client).to receive(:set)
         end
 
-        it "should not call set_last_seen(msg, last_seen_id)" do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .should_not_receive(:set_last_seen)
+        it "should not call set_last_seen" do
+          expect_any_instance_of(described_class).to_not receive(:set_last_seen)
+
+          expect(sequence_table).to receive(:sequence_exists)
 
-          subject = Alephant::Sequencer::Sequencer.new(sequence_table, ident, jsonpath)
-          subject.validate(message, &a_proc)
+          instance.validate(message, &a_proc)
         end
 
         context "keep_all is false" do
           let(:keep_all) { false }
+
           it "should not call the passed block with msg" do
-            subject = Alephant::Sequencer::Sequencer.new(
-              sequence_table,
-              ident,
-              jsonpath,
-              keep_all
-            )
-            subject.validate(message, &an_uncalled_proc)
+            expect(sequence_table).to receive(:sequence_exists)
+
+            opts = {
+              :id => ident,
+              :jsonpath => jsonpath,
+              :keep_all => keep_all,
+              :cache => cache
+            }
+
+            instance = described_class.new(sequence_table, opts)
+            instance.validate(message, &an_uncalled_proc)
           end
         end
       end
 
       context "last_seen_id < sequence_id_from(msg)" do
         before(:each) do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .stub(:get_last_seen)
-            .and_return(stubbed_last_seen)
-
-          Alephant::Sequencer::Sequencer
-            .stub(:sequence_id_from)
-            .and_return(stubbed_seen_high)
+          expect_any_instance_of(described_class).to receive(:get_last_seen).and_return(stubbed_last_seen)
+
+          expect(described_class).to receive(:sequence_id_from).and_return(stubbed_seen_high)
+
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+          expect_any_instance_of(Dalli::Client).to receive(:get)
+          expect_any_instance_of(Dalli::Client).to receive(:set)
         end
 
         it "should call set_last_seen(msg, last_seen_id)" do
-          Alephant::Sequencer::Sequencer
-            .any_instance
-            .should_receive(:set_last_seen)
-            .with(message, stubbed_last_seen)
+          expect_any_instance_of(described_class).to receive(:set_last_seen).with(message, stubbed_last_seen)
+
+          expect(sequence_table).to receive(:sequence_exists)
+
+          instance.validate(message, &a_proc)
+        end
+      end
 
-          subject = Alephant::Sequencer::Sequencer.new(sequence_table, ident, jsonpath)
-          subject.validate(message, &a_proc)
+      context "values already in cache" do
+        before(:each) do
+          expect(message).to receive(:body).and_return("sequence_id" => 5)
+
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+          expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+          expect_any_instance_of(Dalli::Client).to receive(:get).twice.with("ident").and_return(stubbed_last_seen)
+          expect_any_instance_of(Dalli::Client).to_not receive(:set)
+        end
+
+        it "should read values from cache and not database" do
+          expect(sequence_table).to_not receive(:sequence_for)
+          expect(sequence_table).to_not receive(:sequence_exists)
+
+          expect_any_instance_of(described_class).to receive(:set_last_seen).with(message, stubbed_last_seen)
+
+          instance.validate(message, &a_proc)
         end
       end
     end
 
     describe "#get_last_seen" do
+      subject (:instance) {
+        described_class.new(sequence_table, opts)
+      }
+
       it "returns sequence_table.sequence_for(ident)" do
-        table = double()
-        table.stub(:sequence_exists)
-        table.stub(:create)
-        table.should_receive(:sequence_for)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+        expect_any_instance_of(Dalli::Client).to receive(:get).twice
+        expect_any_instance_of(Dalli::Client).to receive(:set).twice
+
+        expect(sequence_table).to receive(:sequence_exists)
+
+        expect(sequence_table).to receive(:sequence_for)
           .with(ident)
           .and_return(:expected_value)
 
-        expect(
-          Alephant::Sequencer::Sequencer
-            .new(table, ident, jsonpath)
-            .get_last_seen
-        ).to eq(:expected_value)
+        expect(instance.get_last_seen).to eq(:expected_value)
       end
     end
 
-    describe "#set_last_seen(data)" do
+    describe "#set_last_seen" do
       before(:each) do
-        Alephant::Sequencer::Sequencer
-          .stub(:sequence_id_from)
-          .and_return(last_seen)
+        expect(described_class).to receive(:sequence_id_from).and_return(last_seen)
+
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+        expect_any_instance_of(Dalli::Client).to receive(:get).twice
+        expect_any_instance_of(Dalli::Client).to receive(:set).twice
       end
 
+      subject (:instance) {
+        described_class.new(sequence_table, opts)
+      }
+
       it "calls update_sequence_id(ident, last_seen)" do
-        table = double()
-        table.stub(:sequence_exists)
-        table.stub(:create)
-        table.stub(:sequence_for)
-        table.should_receive(:update_sequence_id)
+        expect(sequence_table).to receive(:sequence_exists).twice
+
+        expect(sequence_table).to receive(:update_sequence_id)
           .with(ident, last_seen, nil)
 
-        Alephant::Sequencer::Sequencer
-          .new(table, ident, jsonpath)
-          .set_last_seen(data)
+        instance.set_last_seen(data)
       end
     end
 
-    describe ".sequence_id_from(data)" do
-      subject { Alephant::Sequencer::Sequencer }
-
+    describe ".sequence_id_from" do
       it "should return the id described by the set jsonpath" do
         msg = Struct.new(:body).new("set_sequence_id" => 1)
 
-        expect(
-          subject.sequence_id_from(msg, "$.set_sequence_id")
-        ).to eq(1)
+        expect(described_class.sequence_id_from(msg, "$.set_sequence_id")).to eq(1)
       end
     end
 
-    describe "#sequential?(data, jsonpath)" do
+    describe "#sequential?" do
       before(:each) do
-        Alephant::Sequencer::Sequencer
-          .any_instance
-          .stub(:get_last_seen)
-          .and_return(1)
+        expect_any_instance_of(described_class).to receive(:get_last_seen).and_return(1)
 
-        data.stub(:body)
+        expect(data).to receive(:body)
           .and_return("sequence_id" => id_value)
+
+        expect(sequence_table).to receive(:sequence_exists)
+
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+        expect_any_instance_of(Dalli::Client).to receive(:get)
+        expect_any_instance_of(Dalli::Client).to receive(:set)
       end
 
+      subject (:instance) {
+        described_class.new(sequence_table, opts)
+      }
+
       context "jsonpath = '$.sequence_id'" do
         let(:jsonpath) { "$.sequence_id" }
 
-        subject { Alephant::Sequencer::Sequencer.new(sequence_table, :ident, jsonpath) }
-
         context "sequential" do
           let(:id_value) { 2 }
 
           it "is true" do
-            expect(subject.sequential?(data)).to be
+            expect(instance.sequential?(data)).to be
           end
         end
 
@@ -257,7 +335,7 @@ describe Alephant::Sequencer do
           let(:id_value) { 0 }
 
           it "is false" do
-            expect(subject.sequential?(data)).to be false
+            expect(instance.sequential?(data)).to be false
           end
         end
       end
@@ -265,13 +343,11 @@ describe Alephant::Sequencer do
       context "jsonpath = nil" do
         let(:jsonpath) { "$.sequence_id" }
 
-        subject { Alephant::Sequencer::Sequencer.new(sequence_table, :ident, jsonpath) }
-
         context "sequential" do
           let(:id_value) { 2 }
 
           it "is true" do
-            expect(subject.sequential?(data)).to be
+            expect(instance.sequential?(data)).to be
           end
         end
 
@@ -279,21 +355,25 @@ describe Alephant::Sequencer do
           let(:id_value) { 0 }
 
           it "is false" do
-            expect(subject.sequential?(data)).to be false
+            expect(instance.sequential?(data)).to be false
           end
         end
       end
     end
 
     describe "#truncate!" do
+      subject (:instance) {
+        described_class.new(sequence_table, opts)
+      }
+
       it "verify SequenceTable#truncate!" do
-        table = double()
-        table.stub(:create)
-        table.stub(:sequence_exists)
-        table.should_receive(:truncate!)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:initialize)
+        expect_any_instance_of(Dalli::ElastiCache).to receive(:client).and_return(Dalli::Client.new)
+
+        expect(sequence_table).to receive(:sequence_exists)
+        expect(sequence_table).to receive(:truncate!)
 
-        subject = Alephant::Sequencer::Sequencer.new(table, ident, jsonpath)
-        subject.truncate!
+        instance.truncate!
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alephant-sequencer
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - BBC News
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-01-18 00:00:00.000000000 Z
+date: 2016-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -206,6 +206,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: dalli-elasticache
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - FutureMediaNewsRubyGems@bbc.co.uk
@@ -223,6 +237,7 @@ files:
 - Rakefile
 - alephant-sequencer.gemspec
 - lib/alephant/sequencer.rb
+- lib/alephant/sequencer/sequence_cache.rb
 - lib/alephant/sequencer/sequence_table.rb
 - lib/alephant/sequencer/sequencer.rb
 - lib/alephant/sequencer/version.rb