hoodoo 1.13.0 → 1.14.0

data/spec/transient_store/transient_store/memcached_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+
+require 'dalli'
+require 'hoodoo/transient_store/mocks/dalli_client'
+
+# ============================================================================
+
+old_level          = Dalli.logger.level
+Dalli.logger.level = Logger::ERROR
+client             = ::Dalli::Client.new( 'localhost:11211' )
+result             = client.stats() rescue nil
+Dalli.logger.level = old_level
+$memcached_missing = result.is_a?( Hash ) == false || result[ 'localhost:11211' ].nil?
+
+backends = [ :mock ]
+backends << :real unless $memcached_missing
+
+# ============================================================================
+
+describe Hoodoo::TransientStore::Memcached do
+  before :all do
+    @old_level         = Dalli.logger.level
+    Dalli.logger.level = Logger::ERROR
+  end
+
+  after :all do
+    Dalli.logger.level = @old_level
+  end
+
+  it 'registers itself' do
+    expect( Hoodoo::TransientStore.supported_storage_engines() ).to include( :memcached )
+  end
+
+  if $memcached_missing
+    pending "*** WARNING *** Memcached not present on 'localhost:11211', cannot test real engine"
+  end
+
+  shared_examples 'a Memcached abstraction' do | backend |
+
+    # Either expect something on the known mock backend instance or an unknown
+    # (any) real Dalli::Client instance. Can then call "to" - i.e. use:
+    #
+    #     expect_dalli_client( backend ).to...
+    #
+    # +backend+:: Pass either Symbol ":mock" or ":real".
+    #
+    def expect_dalli_client( backend )
+      return case backend
+        when :mock
+          expect( @mock_dalli_client_instance )
+        else
+          expect_any_instance_of( ::Dalli::Client )
+      end
+    end
+
+    # ========================================================================
+
+    before :each do
+      @storage_engine_uri = 'localhost:11211'
+      @namespace          = Hoodoo::UUID.generate()
+
+      if backend == :mock
+        Hoodoo::TransientStore::Mocks::DalliClient.reset()
+        @mock_dalli_client_instance = Hoodoo::TransientStore::Mocks::DalliClient.new
+
+        expect( ::Dalli::Client ).to(
+          receive( :new ).
+          with(
+            @storage_engine_uri,
+            hash_including( { :namespace => @namespace } )
+          ).
+          and_return( @mock_dalli_client_instance )
+        )
+      else
+        expect( ::Dalli::Client ).to(
+          receive( :new ).
+          with(
+            @storage_engine_uri,
+            hash_including( { :namespace => @namespace } )
+          ).
+          and_call_original()
+        )
+      end
+    end
+
+    # ========================================================================
+
+    context "#initialize (#{ backend })" do
+      it 'initialises' do
+        instance = Hoodoo::TransientStore::Memcached.new(
+          storage_host_uri: @storage_engine_uri,
+          namespace:        @namespace
+        )
+
+        expect( instance ).to be_a( Hoodoo::TransientStore::Memcached )
+      end
+
+      it 'complains about strange Memcached behaviour' do
+        expect_dalli_client( backend ).to receive( :stats ).and_return( nil )
+
+        expect {
+          instance = Hoodoo::TransientStore::Memcached.new(
+            storage_host_uri: @storage_engine_uri,
+            namespace:        @namespace
+          )
+        }.to raise_error(
+          RuntimeError,
+          "Hoodoo::TransientStore::Memcached: Did not get back meaningful data from Memcached at '#{ @storage_engine_uri }'"
+        )
+      end
+
+      it 'handles exceptions' do
+        expect_dalli_client( backend ).to receive( :stats ).and_raise( 'Hello world' )
+
+        expect {
+          instance = Hoodoo::TransientStore::Memcached.new(
+            storage_host_uri: @storage_engine_uri,
+            namespace:        @namespace
+          )
+        }.to raise_error(
+          RuntimeError,
+          "Hoodoo::TransientStore::Memcached: Cannot connect to Memcached at '#{ @storage_engine_uri }': Hello world"
+        )
+      end
+    end
+
+    # ========================================================================
+
+    context "when initialised (#{ backend })" do
+      before :each do
+        @instance = Hoodoo::TransientStore::Memcached.new(
+          storage_host_uri: @storage_engine_uri,
+          namespace:        @namespace
+        )
+
+        @key      = Hoodoo::UUID.generate()
+        @payload  = { 'bar' => 'baz' }
+        @ttl      = 120
+      end
+
+      context '#set' do
+        it 'sets' do
+          expect_dalli_client( backend ).to receive( :set ).with( @key, @payload, @ttl ).and_call_original()
+
+          result = @instance.set(
+            key:              @key,
+            payload:          @payload,
+            maximum_lifespan: @ttl
+          )
+
+          expect( result ).to eq( true )
+        end
+
+        it 'allows exceptions to propagate' do
+          expect_dalli_client( backend ).to receive( :set ).with( @key, @payload, @ttl ).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_dalli_client( backend ).to receive( :set ).with( @key, @payload, @ttl ).and_call_original()
+
+          @instance.set(
+            key:              @key,
+            payload:          @payload,
+            maximum_lifespan: @ttl
+          )
+        end
+
+        it 'gets known keys' do
+          expect_dalli_client( backend ).to receive( :get ).with( @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 'allows exceptions to propagate' do
+          expect_dalli_client( backend ).to receive( :get ).with( @key ).and_raise( 'Hello world' )
+
+          expect {
+            @instance.get( key: @key )
+          }.to raise_error( RuntimeError, "Hello world" )
+        end
+      end
+
+      context '#delete' do
+        before :each do
+          expect_dalli_client( backend ).to receive( :set ).with( @key, @payload, @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_dalli_client( backend ).to receive( :delete ).with( @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 exceptions to propagate' do
+          expect_dalli_client( backend ).to receive( :delete ).with( @key ).and_raise( 'Hello world' )
+
+          expect {
+            @instance.delete( key: @key )
+          }.to raise_error( RuntimeError, "Hello world" )
+        end
+      end
+
+      context 'close' do
+        it 'closes' do
+          expect_dalli_client( backend ).to receive( :close )
+          @instance.close()
+        end
+      end
+
+    end # 'context "when initialised (#{ backend })" do'
+  end   # 'shared_examples ...'
+
+  backends.each do | backend |
+    it_behaves_like( 'a Memcached abstraction', backend )
+  end
+
+end # 'describe...'

data/spec/transient_store/transient_store/mocks/dalli_client_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+# Most of the mock client is covered by the TransientStore Memcached layer
+# tests, which use the mock backend as well as a real one. Tests are implicit.
+# This file contains any additional coverage not handled in
+# transient_store/transient_store/memcached_spec.rb already.
+#
+describe Hoodoo::TransientStore::Mocks::DalliClient do
+
+  context 'sanctioned and maintained method' do
+    it '::store() returns the data store' do
+      Hoodoo::TransientStore::Mocks::DalliClient.reset()
+      mock_dalli_client_instance = Hoodoo::TransientStore::Mocks::DalliClient.new
+      mock_dalli_client_instance.set( 'foo', 'bar' )
+      expect( Hoodoo::TransientStore::Mocks::DalliClient.store ).to have_key( 'foo' )
+    end
+  end
+
+  # ==========================================================================
+
+  context 'deprecated but indefinitely maintained method' do
+
+    # Chicken and egg - we need to use the methods we're going to test in the
+    # test setup to avoid breaking or being broken by prior test execution!
+
+    before :all do
+      @old_bypass = Hoodoo::TransientStore::Mocks::DalliClient.bypass?
+      Hoodoo::TransientStore::Mocks::DalliClient.bypass( false )
+    end
+
+    after :all do
+      Hoodoo::TransientStore::Mocks::DalliClient.bypass( @old_bypass )
+    end
+
+    it '::bypass=(...) sets and ::bypass?() reads the "bypass" flag' do
+      Hoodoo::TransientStore::Mocks::DalliClient.bypass( true )
+      expect( Hoodoo::TransientStore::Mocks::DalliClient.bypass? ).to eql( true )
+
+      Hoodoo::TransientStore::Mocks::DalliClient.bypass( false )
+      expect( Hoodoo::TransientStore::Mocks::DalliClient.bypass? ).to eql( false )
+    end
+  end
+
+end

data/spec/transient_store/transient_store/mocks/redis_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+# Most of the mock client is covered by the TransientStore Redis layer tests,
+# which use the mock backend as well as a real one. Tests are implicit. This
+# file contains any additional coverage not handled in
+# transient_store/transient_store/redis_spec.rb already.
+#
+describe Hoodoo::TransientStore::Mocks::Redis do
+
+  context 'sanctioned and maintained method' do
+    it '::store() returns the data store' do
+      Hoodoo::TransientStore::Mocks::Redis.reset()
+      mock_redis_instance = Hoodoo::TransientStore::Mocks::Redis.new
+      mock_redis_instance.set( 'foo', 'bar' )
+      expect( Hoodoo::TransientStore::Mocks::Redis.store ).to have_key( 'foo' )
+    end
+
+    it '#expire(...) raises an error for attempts to expire bad keys' do
+      mock_redis_instance = Hoodoo::TransientStore::Mocks::Redis.new
+      key                 = Hoodoo::UUID.generate()
+
+      expect {
+        mock_redis_instance.expire( key, 60 )
+      }.to raise_error( RuntimeError, "Hoodoo::TransientStore::Mocks::Redis\#expire: Cannot find key '#{ key }'" )
+    end
+  end
+
+end

data/spec/transient_store/transient_store/redis_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+require 'redis'
+require 'hoodoo/transient_store/mocks/redis'
+
+# ============================================================================
+
+client = ::Redis.new( :url => 'redis://localhost:6379' )
+result = client.info( 'CPU' ) rescue nil
+
+$redis_missing = result.is_a?( Hash ) == false
+
+backends = [ :mock ]
+backends << :real unless $redis_missing
+
+# ============================================================================
+
+describe Hoodoo::TransientStore::Redis do
+
+  it 'registers itself' do
+    expect( Hoodoo::TransientStore.supported_storage_engines() ).to include( :redis )
+  end
+
+  if $redis_missing
+    pending "*** WARNING *** Redis not present on 'redis://localhost:6379', cannot test real engine"
+  end
+
+  shared_examples 'a Redis abstraction' do | backend |
+
+    # Either expect something on the known mock Redis instance, or an unknown
+    # (any) real Redis instance. Can then call "to" - i.e. use:
+    #
+    #     expect_redis( backend ).to...
+    #
+    # +backend+:: Pass either Symbol ":mock" or ":real".
+    #
+    def expect_redis( backend )
+      return case backend
+        when :mock
+          expect( @mock_redis_instance )
+        else
+          expect_any_instance_of( ::Redis )
+      end
+    end
+
+    # ========================================================================
+
+    before :each do
+      @storage_engine_uri = 'redis://localhost:6379'
+      @namespace          = Hoodoo::UUID.generate()
+
+      if backend == :mock
+        Hoodoo::TransientStore::Mocks::Redis.reset()
+        @mock_redis_instance = Hoodoo::TransientStore::Mocks::Redis.new
+
+        expect( ::Redis ).to(
+          receive( :new ).
+          with( hash_including( { :url => @storage_engine_uri } ) ).
+          and_return( @mock_redis_instance )
+        )
+      else
+        expect( ::Redis ).to(
+          receive( :new ).
+          with( hash_including( { :url => @storage_engine_uri } ) ).
+          and_call_original()
+        )
+      end
+    end
+
+    # ========================================================================
+
+    context "#initialize (#{ backend })" do
+      it 'initialises' do
+        instance = Hoodoo::TransientStore::Redis.new(
+          storage_host_uri: @storage_engine_uri,
+          namespace:        @namespace
+        )
+
+        expect( instance ).to be_a( Hoodoo::TransientStore::Redis )
+      end
+
+      it 'complains about strange Redis behaviour' do
+        expect_redis( backend ).to receive( :info ).and_return( nil )
+
+        expect {
+          instance = Hoodoo::TransientStore::Redis.new(
+            storage_host_uri: @storage_engine_uri,
+            namespace:        @namespace
+          )
+        }.to raise_error(
+          RuntimeError,
+          "Hoodoo::TransientStore::Redis: Did not get back meaningful data from Redis at '#{ @storage_engine_uri }'"
+        )
+      end
+
+      it 'handles exceptions' do
+        expect_redis( backend ).to receive( :info ).and_raise( 'Hello world' )
+
+        expect {
+          instance = Hoodoo::TransientStore::Redis.new(
+            storage_host_uri: @storage_engine_uri,
+            namespace:        @namespace
+          )
+        }.to raise_error(
+          RuntimeError,
+          "Hoodoo::TransientStore::Redis: Cannot connect to Redis at '#{ @storage_engine_uri }': Hello world"
+        )
+      end
+
+      it 'generates expected namespaced keys' do
+        instance = Hoodoo::TransientStore::Redis.new(
+          storage_host_uri: @storage_engine_uri,
+          namespace:        @namespace
+        )
+
+        expect( instance.send( :namespaced_key, 'foo' ) ).to eql( "#{ @namespace }foo" )
+      end
+    end
+
+    # ========================================================================
+
+    context "when initialised (#{ backend })" do
+      before :each do
+        @instance = Hoodoo::TransientStore::Redis.new(
+          storage_host_uri: @storage_engine_uri,
+          namespace:        @namespace
+        )
+
+        @key      = Hoodoo::UUID.generate()
+        @nskey    = @instance.send( :namespaced_key, @key )
+        @payload  = { 'bar' => 'baz' }
+        @jpayload = JSON.fast_generate( @payload )
+        @ttl      = 120
+      end
+
+      context '#set' do
+        it 'sets' do
+          expect_redis( backend ).to receive( :[]=    ).with( @nskey, @jpayload ).and_call_original()
+          expect_redis( backend ).to receive( :expire ).with( @nskey, @ttl      ).and_call_original()
+
+          result = @instance.set(
+            key:              @key,
+            payload:          @payload,
+            maximum_lifespan: @ttl
+          )
+
+          expect( result ).to eq( true )
+        end
+
+        it 'allows exceptions to propagate' do
+          expect_redis( backend ).to receive( :[]= ).with( @nskey, @jpayload ).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_redis( backend ).to receive( :[]=    ).with( @nskey, @jpayload ).and_call_original()
+          expect_redis( backend ).to receive( :expire ).with( @nskey, @ttl      ).and_call_original()
+
+          @instance.set(
+            key:              @key,
+            payload:          @payload,
+            maximum_lifespan: @ttl
+          )
+        end
+
+        it 'gets known keys' do
+          expect_redis( backend ).to receive( :[] ).with( @nskey ).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 'allows exceptions to propagate' do
+          expect_redis( backend ).to receive( :[] ).with( @nskey ).and_raise( 'Hello world' )
+
+          expect {
+            @instance.get( key: @key )
+          }.to raise_error( RuntimeError, "Hello world" )
+        end
+      end
+
+      context '#delete' do
+        before :each do
+          expect_redis( backend ).to receive( :[]=    ).with( @nskey, @jpayload ).and_call_original()
+          expect_redis( backend ).to receive( :expire ).with( @nskey, @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_redis( backend ).to receive( :del ).with( @nskey ).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 exceptions to propagate' do
+          expect_redis( backend ).to receive( :del ).with( @nskey ).and_raise( 'Hello world' )
+
+          expect {
+            @instance.delete( key: @key )
+          }.to raise_error( RuntimeError, "Hello world" )
+        end
+      end
+
+      context 'close' do
+        it 'closes' do
+          expect_redis( backend ).to receive( :quit )
+          @instance.close()
+        end
+      end
+
+    end # 'context "when initialised (#{ backend })" do'
+  end   # 'shared_examples ...'
+
+  backends.each do | backend |
+    it_behaves_like( 'a Redis abstraction', backend )
+  end
+
+end # 'describe...'