hoodoo 1.13.0 → 1.14.0

data/spec/services/services/session_spec.rb

@@ -3,7 +3,14 @@ require 'spec_helper'
 describe Hoodoo::Services::Session do
 
   before :each do
-    Hoodoo::Services::Session::MockDalliClient.reset()
+    Hoodoo::TransientStore::Mocks::DalliClient.reset()
+  end
+
+  it 'includes a legacy alias to the TransientStore mock back-end' do
+    expect( Hoodoo::Services::Session::MockDalliClient == Hoodoo::TransientStore::Mocks::DalliClient ).to eql( true )
+    expect {
+      Hoodoo::TransientStore::Mocks::DalliClient.reset()
+    }.to_not raise_error
   end
 
   it 'initialises with default options' do
@@ -109,7 +116,7 @@ describe Hoodoo::Services::Session do
 
     expect( s1.save_to_memcached ).to eq( :ok )
 
-    store = Hoodoo::Services::Session::MockDalliClient.store()
+    store = Hoodoo::TransientStore::Mocks::DalliClient.store()
     expect( store[ '1234' ] ).to_not be_nil
     expect( store[ '0987' ] ).to eq( { :expires_at => nil, :value => { 'version' => 2 } } )
 
@@ -135,7 +142,7 @@ describe Hoodoo::Services::Session do
   end
 
   it 'refuses to save if a newer caller version is present' do
-    expect( described_class ).to receive( :connect_to_memcached ).twice.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    expect( described_class ).to receive( :connect_to_memcached ).twice.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
 
     # Save a session with a high caller version
 
@@ -162,7 +169,7 @@ describe Hoodoo::Services::Session do
   end
 
   it 'invalidates a session if the client ID advances during its lifetime' do
-    expect( described_class ).to receive( :connect_to_memcached ).exactly( 4 ).times.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    expect( described_class ).to receive( :connect_to_memcached ).exactly( 4 ).times.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
     loader = described_class.new
 
     # Save a session with a low caller version.
@@ -194,7 +201,7 @@ describe Hoodoo::Services::Session do
   end
 
   it 'refuses to load if the caller version is outdated' do
-    expect( described_class ).to receive( :connect_to_memcached ).exactly( 5 ).times.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    expect( described_class ).to receive( :connect_to_memcached ).exactly( 5 ).times.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
     loader = described_class.new
 
     # Save a session with a low caller version
@@ -233,7 +240,7 @@ describe Hoodoo::Services::Session do
   end
 
   it 'refuses to load if expired' do
-    expect( described_class ).to receive( :connect_to_memcached ).twice.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    expect( described_class ).to receive( :connect_to_memcached ).twice.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
     loader = described_class.new
 
     # Save a session with a high caller version
@@ -263,18 +270,18 @@ describe Hoodoo::Services::Session do
       :caller_version => 1
     )
 
-    expect( described_class ).to receive( :connect_to_memcached ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    expect( described_class ).to receive( :connect_to_memcached ).once.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
 
     expect( s.update_caller_version_in_memcached( '9944', 23                                                 ) ).to eq( :ok )
-    expect( s.update_caller_version_in_memcached( 'abcd', 2,  Hoodoo::Services::Session::MockDalliClient.new ) ).to eq( :ok )
+    expect( s.update_caller_version_in_memcached( 'abcd', 2,  Hoodoo::TransientStore::Mocks::DalliClient.new ) ).to eq( :ok )
 
-    store = Hoodoo::Services::Session::MockDalliClient.store()
+    store = Hoodoo::TransientStore::Mocks::DalliClient.store()
     expect( store[ '9944' ] ).to eq( { :expires_at => nil, :value => { 'version' => 23 } } )
     expect( store[ 'abcd' ] ).to eq( { :expires_at => nil, :value => { 'version' => 2  } } )
   end
 
   it 'handles invalid session IDs when loading' do
-    expect( described_class ).to receive( :connect_to_memcached ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+    expect( described_class ).to receive( :connect_to_memcached ).once.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
     loader = described_class.new
     expect( loader.load_from_memcached!( '1234' ) ).to eq( :not_found )
   end
@@ -289,7 +296,7 @@ describe Hoodoo::Services::Session do
   it 'logs Memcached exceptions when loading' do
     loader = described_class.new
 
-    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :get ).once do
+    expect_any_instance_of( Hoodoo::TransientStore::Mocks::DalliClient ).to receive( :get ).once do
       raise 'Mock Memcached connection failure'
     end
 
@@ -312,7 +319,7 @@ describe Hoodoo::Services::Session do
     # The first 'set' call is an attempt to update the caller version before
     # the updated session is saved.
 
-    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :set ).once do
+    expect_any_instance_of( Hoodoo::TransientStore::Mocks::DalliClient ).to receive( :set ).once do
       raise 'Mock Memcached connection failure'
     end
 
@@ -332,8 +339,8 @@ describe Hoodoo::Services::Session do
       :caller_version => 1
     )
 
-    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :set ).once.and_call_original
-    expect_any_instance_of( Hoodoo::Services::Session::MockDalliClient ).to receive( :set ).once do
+    expect_any_instance_of( Hoodoo::TransientStore::Mocks::DalliClient ).to receive( :set ).once.and_call_original
+    expect_any_instance_of( Hoodoo::TransientStore::Mocks::DalliClient ).to receive( :set ).once do
       raise 'Mock Memcached connection failure'
     end
 
@@ -372,7 +379,7 @@ describe Hoodoo::Services::Session do
   end
 
   it 'logs and reports deletion exceptions' do
-    fdc = Hoodoo::Services::Session::MockDalliClient.new
+    fdc = Hoodoo::TransientStore::Mocks::DalliClient.new
     s = described_class.new(
       :session_id => '1234',
       :memcached_host => 'abcd',
@@ -397,11 +404,11 @@ describe Hoodoo::Services::Session do
     before :example do
       # Clear the connection cache for each test
       Hoodoo::Services::Session.class_variable_set( '@@dalli_clients', nil ) # Hack for test!
-      Hoodoo::Services::Session::MockDalliClient.bypass( true )
+      Hoodoo::TransientStore::Mocks::DalliClient.bypass( true )
     end
 
     after :example do
-      Hoodoo::Services::Session::MockDalliClient.bypass( false )
+      Hoodoo::TransientStore::Mocks::DalliClient.bypass( false )
     end
 
     it 'complains about a missing host' do
@@ -437,13 +444,13 @@ describe Hoodoo::Services::Session do
     end
 
     it 'only initialises once for one given host' do
-      expect( Dalli::Client ).to receive( :new ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+      expect( Dalli::Client ).to receive( :new ).once.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
 
       1.upto( 3 ) do
         described_class.connect_to_memcached( 'one' )
       end
 
-      expect( Dalli::Client ).to receive( :new ).once.and_return( Hoodoo::Services::Session::MockDalliClient.new )
+      expect( Dalli::Client ).to receive( :new ).once.and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
 
       1.upto( 3 ) do
         described_class.connect_to_memcached( 'two' )

data/spec/transient_store/transient_store/base_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Hoodoo::TransientStore::Base do
+  context 'creation' do
+    it 'initialises' do
+      base = Hoodoo::TransientStore::Base.new(
+        storage_host_uri: 'localhost',
+        namespace:        'foo'
+      )
+
+      expect( base ).to_not be_nil
+
+      # Subclasses may rightly rely on these, so they should be tested.
+      #
+      expect( base.instance_variable_get( '@storage_host_uri' ) ).to eq( 'localhost' )
+      expect( base.instance_variable_get( '@namespace'        ) ).to eq( 'foo'       )
+    end
+  end
+
+  context 'subclass author warning' do
+    before :each do
+      @base = Hoodoo::TransientStore::Base.new(
+        storage_host_uri: 'localhost',
+        namespace:        'foo'
+      )
+    end
+
+    it 'is generated for #get' do
+      expect {
+        @base.set( key: 'foo', payload: {}, maximum_lifespan: 5 )
+      }.to raise_error( RuntimeError, 'Subclasses must implement Hoodoo::TransientStore::Base#set' )
+    end
+
+    it 'is generated for #set' do
+      expect {
+        @base.get( key: 'foo' )
+      }.to raise_error( RuntimeError, 'Subclasses must implement Hoodoo::TransientStore::Base#get' )
+    end
+
+    it 'is generated for #delete' do
+      expect {
+        @base.delete( key: 'foo' )
+      }.to raise_error( RuntimeError, 'Subclasses must implement Hoodoo::TransientStore::Base#delete' )
+    end
+
+    it 'is generated for #close' do
+      expect {
+        @base.close()
+      }.to raise_error( RuntimeError, 'Subclasses must implement Hoodoo::TransientStore::Base#close' )
+    end
+  end
+end

data/spec/transient_store/transient_store/memcached_redis_mirror_spec.rb

@@ -0,0 +1,380 @@
+require 'spec_helper'
+
+require 'hoodoo/transient_store/mocks/dalli_client'
+require 'hoodoo/transient_store/mocks/redis'
+
+# These tests make sure that the mirror class calls down to the Memcached and
+# Redis abstractions, but assumes those abstractions are thoroughly tested by
+# their own unit tests. So it makes sure it gets expected call and result
+# behaviour, but doesn't worry about mock or real Redis and so-on.
+#
+describe Hoodoo::TransientStore::MemcachedRedisMirror do
+
+  it 'registers itself' do
+    expect( Hoodoo::TransientStore.supported_storage_engines() ).to include( :memcached_redis_mirror )
+  end
+
+  before :each do
+    @memcached_uri      = 'localhost:11211'
+    @redis_uri          = 'redis://localhost:6379'
+    @namespace          = Hoodoo::UUID.generate()
+    @storage_engine_uri = {
+      :memcached => @memcached_uri,
+      :redis     => @redis_uri
+    }
+
+    # Use pure mock back-ends behind the Memcached and Redis abstraction
+    # layers; real back-end tests are done for them in their unit tests.
+
+    Hoodoo::TransientStore::Mocks::DalliClient.reset()
+    Hoodoo::TransientStore::Mocks::Redis.reset()
+
+    allow( Dalli::Client ).to(
+      receive( :new ).
+      and_return( Hoodoo::TransientStore::Mocks::DalliClient.new )
+    )
+
+    allow( Redis ).to(
+      receive( :new ).
+      and_return( Hoodoo::TransientStore::Mocks::Redis.new )
+    )
+
+    @instance = Hoodoo::TransientStore::MemcachedRedisMirror.new(
+      storage_host_uri: @storage_engine_uri,
+      namespace:        @namespace
+    )
+  end
+
+  # ==========================================================================
+
+  context '#initialize' do
+    it 'initialises' do
+      expect( @instance ).to be_a( Hoodoo::TransientStore::MemcachedRedisMirror )
+    end
+
+    it 'complains about bad parameters' do
+      expect {
+        Hoodoo::TransientStore::MemcachedRedisMirror.new(
+          storage_host_uri: 'some string',
+          namespace:        @namespace
+        )
+      }.to raise_error( RuntimeError, 'Hoodoo::TransientStore::MemcachedRedisMirror: Bad storage host URI data passed to constructor' )
+
+      expect {
+        Hoodoo::TransientStore::MemcachedRedisMirror.new(
+          storage_host_uri: { :hash => 'without required keys' },
+          namespace:        @namespace
+        )
+      }.to raise_error( RuntimeError, 'Hoodoo::TransientStore::MemcachedRedisMirror: Bad storage host URI data passed to constructor' )
+    end
+
+    it 'creates Memcached and Redis instances' do
+      expect( Hoodoo::TransientStore::Memcached ).to receive( :new )
+      expect( Hoodoo::TransientStore::Redis     ).to receive( :new )
+
+      Hoodoo::TransientStore::MemcachedRedisMirror.new(
+        storage_host_uri: @storage_engine_uri,
+        namespace:        @namespace
+      )
+    end
+  end
+
+  # ==========================================================================
+
+  context 'when initialised' do
+    before :each do
+      @key      = Hoodoo::UUID.generate()
+      @payload  = { 'bar' => 'baz' }
+      @ttl      = 120
+    end
+
+    context '#set' do
+      it 'sets' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :set ).with( key: @key, payload: @payload, maximum_lifespan: @ttl ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :set ).with( key: @key, payload: @payload, maximum_lifespan: @ttl ).and_call_original()
+
+        result = @instance.set(
+          key:              @key,
+          payload:          @payload,
+          maximum_lifespan: @ttl
+        )
+
+        expect( result ).to eq( true )
+      end
+
+      it 'allows Memcached exceptions to propagate' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :set ).and_raise( 'Hello world' )
+
+        expect {
+          @instance.set(
+            key:              @key,
+            payload:          @payload,
+            maximum_lifespan: @ttl
+          )
+        }.to raise_error( RuntimeError, "Hello world" )
+      end
+
+      it 'allows Redis exceptions to propagate' do
+        expect_any_instance_of( Hoodoo::TransientStore::Redis ).to receive( :set ).and_raise( 'Hello world' )
+
+        expect {
+          @instance.set(
+            key:              @key,
+            payload:          @payload,
+            maximum_lifespan: @ttl
+          )
+        }.to raise_error( RuntimeError, "Hello world" )
+      end
+    end
+
+    context '#get' do
+      before :each do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :set ).with( key: @key, payload: @payload, maximum_lifespan: @ttl ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :set ).with( key: @key, payload: @payload, maximum_lifespan: @ttl ).and_call_original()
+
+        @instance.set(
+          key:              @key,
+          payload:          @payload,
+          maximum_lifespan: @ttl
+        )
+      end
+
+      it 'gets known keys' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :get ).with( key: @key ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :get ).with( key: @key ).and_call_original()
+
+        expect( @instance.get( key: @key ) ).to eql( @payload )
+      end
+
+      it 'returns "nil" for unknown keys' do
+        expect( @instance.get( key: Hoodoo::UUID.generate() ) ).to be_nil
+      end
+
+      it 'returns "nil" if Memcached is missing the data' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :get ).with( key: @key ).and_return( nil )
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :get ).with( key: @key ).and_call_original()
+
+        expect( @instance.get( key: @key ) ).to be_nil
+      end
+
+      it 'returns "nil" if Redis is missing the data' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :get ).with( key: @key ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :get ).with( key: @key ).and_return( nil )
+
+        expect( @instance.get( key: @key ) ).to be_nil
+      end
+
+      it 'allows Memcached exceptions to propagate' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :get ).and_raise( 'Hello world' )
+
+        expect {
+          @instance.get( key: @key )
+        }.to raise_error( RuntimeError, "Hello world" )
+      end
+
+      it 'allows Redis exceptions to propagate' do
+        expect_any_instance_of( Hoodoo::TransientStore::Redis ).to receive( :get ).and_raise( 'Hello world' )
+
+        expect {
+          @instance.get( key: @key )
+        }.to raise_error( RuntimeError, "Hello world" )
+      end
+
+      context 'with migration selector of' do
+        context ':both' do
+          it 'is the default' do
+            expect( @instance.get_keys_from ).to eql( :both )
+          end
+
+          # This is covered elsewhere too but belt-and-braces checks don't hurt
+          # and the test list looks cleaner when this one section covers all
+          # allowed values of the selector.
+
+          it 'returns data if the key is in both engines' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :get ).with( key: @key ).and_call_original()
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :get ).with( key: @key ).and_call_original()
+
+            expect( @instance.get( key: @key ) ).to eql( @payload )
+          end
+
+          it 'returns "nil" if the key is only in Memcached' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :get ).with( key: @key ).and_call_original()
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :get ).with( key: @key ).and_return( nil )
+
+            expect( @instance.get( key: @key ) ).to be_nil
+          end
+
+          it 'returns "nil" if the key is only in Redis' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :get ).with( key: @key ).and_return( nil )
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :get ).with( key: @key ).and_call_original()
+
+            expect( @instance.get( key: @key ) ).to be_nil
+          end
+        end
+
+        context ':memcached' do
+          before( :each ) { @instance.get_keys_from = :memcached }
+           after( :each ) { @instance.get_keys_from = :both  }
+
+          it 'returns data if the key is in both engines' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to     receive( :get ).with( key: @key ).and_call_original()
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to_not receive( :get )
+
+            expect( @instance.get( key: @key ) ).to eql( @payload )
+          end
+
+          it 'returns data if the key is only in Memcached' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to     receive( :get ).with( key: @key ).and_call_original()
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to_not receive( :get )
+
+            expect( @instance.get( key: @key ) ).to eql( @payload )
+          end
+
+          it 'returns "nil" if the key is only in Redis' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to     receive( :get ).with( key: @key ).and_return( nil )
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to_not receive( :get )
+
+            expect( @instance.get( key: @key ) ).to be_nil
+          end
+        end
+
+        context ':redis' do
+          before( :each ) { @instance.get_keys_from = :redis }
+           after( :each ) { @instance.get_keys_from = :both  }
+
+          it 'returns data if the key is in both engines' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to_not receive( :get )
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to     receive( :get ).with( key: @key ).and_call_original()
+
+            expect( @instance.get( key: @key ) ).to eql( @payload )
+          end
+
+          it 'returns "nil" if the key is only in Memcached' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to_not receive( :get )
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to     receive( :get ).with( key: @key ).and_return( nil )
+
+            expect( @instance.get( key: @key ) ).to be_nil
+          end
+
+          it 'returns data if the key is only in Redis' do
+            expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to_not receive( :get )
+            expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to     receive( :get ).with( key: @key ).and_call_original()
+
+            expect( @instance.get( key: @key ) ).to eql( @payload )
+          end
+        end
+
+        context 'an unrecognised value' do
+          before( :each ) { @instance.get_keys_from = :foo  }
+           after( :each ) { @instance.get_keys_from = :both }
+
+          it 'causes complaint' do
+            expect {
+              @instance.get( key: @key )
+            }.to raise_error( RuntimeError, "Hoodoo::TransientStore::Base\#get: Invalid prior value given in \#get_keys_from= of ':foo' - only ':both', ':memcached' or ':redis' are allowed" )
+          end
+        end
+      end
+    end
+
+    context '#delete' do
+      before :each do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :set ).with( key: @key, payload: @payload, maximum_lifespan: @ttl ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :set ).with( key: @key, payload: @payload, maximum_lifespan: @ttl ).and_call_original()
+
+        @instance.set(
+          key:              @key,
+          payload:          @payload,
+          maximum_lifespan: @ttl
+        )
+      end
+
+      it 'deletes known keys' do
+        expect( @instance.get( key: @key ) ).to eql( @payload )
+
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :delete ).with( key: @key ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :delete ).with( key: @key ).and_call_original()
+
+        result = @instance.delete( key: @key )
+
+        expect( result ).to eq( true )
+        expect( @instance.get( key: @key ) ).to eql( nil )
+      end
+
+      it 'ignores unknown keys' do
+        expect( @instance.delete( key: Hoodoo::UUID.generate() ) ).to eql( true )
+      end
+
+      it 'allows Memcached exceptions to propagate but still calls Redis' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :delete ).and_raise( 'Hello world' )
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :delete ).with( key: @key ).and_call_original()
+
+        expect {
+          @instance.delete( key: @key )
+        }.to raise_error( RuntimeError, "Hello world" )
+      end
+
+      it 'allows Redis exceptions to propagate but still calls Memcached' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :delete ).with( key: @key ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :delete ).and_raise( 'Hello world' )
+
+        expect {
+          @instance.delete( key: @key )
+        }.to raise_error( RuntimeError, "Hello world" )
+      end
+
+      it 'deletes from Memcached even if the Redis data is missing' do
+        expect( @instance.get( key: @key ) ).to eql( @payload )
+
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :delete ).with( key: @key ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :delete ).with( key: @key ).and_call_original()
+
+        Hoodoo::TransientStore::Mocks::Redis.reset()
+
+        result = @instance.delete( key: @key )
+
+        expect( result ).to eq( true )
+        expect( @instance.get( key: @key ) ).to eql( nil )
+      end
+
+      it 'deletes from Redis even if the Memcached data is missing' do
+        expect( @instance.get( key: @key ) ).to eql( @payload )
+
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :delete ).with( key: @key ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :delete ).with( key: @key ).and_call_original()
+
+        Hoodoo::TransientStore::Mocks::DalliClient.reset()
+
+        result = @instance.delete( key: @key )
+
+        expect( result ).to eq( true )
+        expect( @instance.get( key: @key ) ).to eql( nil )
+      end
+    end
+
+    context '#close' do
+      it 'closes normally' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :close ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :close ).and_call_original()
+
+        @instance.close()
+      end
+
+      it 'still closes Redis if Memcached raises an exception' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :close ).and_raise( "Hello world" )
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :close ).and_call_original()
+
+        @instance.close() rescue nil
+      end
+
+      it 'still closes Memcached if Redis raises an exception' do
+        expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :close ).and_call_original()
+        expect_any_instance_of( Hoodoo::TransientStore::Redis     ).to receive( :close ).and_raise( "Hello world" )
+
+        @instance.close() rescue nil
+      end
+    end
+
+  end # 'context "when initialised (#{ backend })" do'
+
+end # 'describe...'