hella-redis 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA1: 
-  data.tar.gz: d5d4a583bea7f4eb74d904bddce9474a5c218dcc
-  metadata.gz: 6d10bd47816a27aa7924ac5cecdb22df2659423a
 SHA512: 
-  data.tar.gz: 2986489323f0237fe4f4b001b74df13962744630892d14b4135ae316cfca3b8eb2c258c372db76aded8e7fd40c626155239d3d5d97e77957b4fac6010fd7dabf
-  metadata.gz: ada755c656466edf8b8a93837b9883e3fc5dbb597169820c7e126361a38e44ebba6670cba18e3c19dccfecec4986863b413540e09f8ad6b7c1c7b8122f9d1318
+  data.tar.gz: 6b2cc12d83fbb6e7b9729c89a60bb39c583bcd52543f1f1d77b3c39c05c1c58f5faac2de941ae34d4d47b22ebfff5eb7bf2847fb3d1580609283c333a4332384
+  metadata.gz: 570acf22296c63f86218648a9e02c9c8d11d34eeba378e86ea5014e3ea21ca6e26390d7edd3f849ab345fb17d5a8fe9696ba5411412b54d5e2da505134223ce5
+SHA1: 
+  data.tar.gz: a42078e26d25b13db394f27b31e44f41a2b4fba6
+  metadata.gz: 4c3dd50a8c11051d7c263d9eab72f7b48c47ded5

data/README.md

@@ -2,24 +2,55 @@
 
 It's-a hella-redis!
 
-## Usage
+This gem is a wrapper that builds a connection pool of redis connections.  It also provides spies and test mode behavior to ease testing redis interactions.
 
-### Connection
+## Usage
 
 ```ruby
-# config and create a connection
-@config = {
+# create
+@redis = HellaRedis.new({
   :timeout  => 1,
   :size     => 5,
   :redis_ns => 'hella-redis-test',
   :driver   => 'ruby',
   :url      => 'redis://localhost:6379/0'
-}
-@conn = HellaRedis::Connection.new(@config)
+}) # => HellaRedis:ConnectionPool instance
 
 # it's actually a pool of connections
-@conn.with do |conn|
-  # get a connection and do something with it
+@redis.connection do |connection|
+  # checks out a connection so you can do something with it
+  # will check it back in once the block has run
+end
+```
+
+### Test Mode
+
+```ruby
+ENV['HELLA_REDIS_TEST_MODE'] = 'yes' # set to anything "truthy"
+
+@redis_spy = HellaRedis.new({
+  :timeout  => 1,
+  :size     => 5,
+  :redis_ns => 'hella-redis-test',
+  :driver   => 'ruby',
+  :url      => 'redis://localhost:6379/0'
+}) # => HellaRedis::ConnectionPoolSpy instance
+
+@redis_spy.connection do |connection_spy|
+  connection_spy # => HellaRedis::ConnectionSpy instance
+  connection_spy.info
+end
+
+@redis_spy.calls.size # => 1
+@redis_spy.calls.first.tap do |call|
+  call.command # => 'info'
+  call.args    # => nil
+  call.block   # => nil
+end
+
+@redis_spy.connection_calls.size # => 1
+@redis_spy.connection_calls.first.tap do |connection_call|
+  connection_call.block # => block instance
 end
 ```
 

data/lib/hella-redis.rb

@@ -1,5 +1,46 @@
 require 'hella-redis/version'
-require 'hella-redis/connection'
+require 'hella-redis/connection_pool'
+require 'hella-redis/connection_pool_spy'
 
 module HellaRedis
+
+  def self.new(args)
+    self.send(ENV['HELLA_REDIS_TEST_MODE'] ? :mock : :real, args)
+  end
+
+  def self.real(args)
+    ConnectionPool.new(Config.new(args))
+  end
+
+  def self.mock(args)
+    ConnectionPoolSpy.new(Config.new(args))
+  end
+
+  class Config
+
+    attr_reader :url, :driver, :redis_ns, :timeout, :size
+
+    def initialize(args = nil)
+      args ||= {}
+      @url      = args[:url]
+      @driver   = args[:driver]
+      @redis_ns = args[:redis_ns]
+      @timeout  = args[:timeout]
+      @size     = args[:size] || 1
+    end
+
+    def ==(other_config)
+      if other_config.kind_of?(Config)
+        self.url      == other_config.url      &&
+        self.driver   == other_config.driver   &&
+        self.redis_ns == other_config.redis_ns &&
+        self.timeout  == other_config.timeout  &&
+        self.size     == other_config.size
+      else
+        super
+      end
+    end
+
+  end
+
 end

data/lib/hella-redis/connection_pool.rb

@@ -0,0 +1,31 @@
+require 'connection_pool'
+require 'redis'
+require 'redis-namespace'
+
+module HellaRedis
+
+  class ConnectionPool
+
+    def initialize(config)
+      @pool = ::ConnectionPool.new({
+        :timeout => config.timeout,
+        :size    => config.size
+      }) do
+        ::Redis::Namespace.new(config.redis_ns, {
+          :redis => ::Redis.new({
+            :url    => config.url,
+            :driver => config.driver
+          })
+        })
+      end
+    end
+
+    def connection
+      @pool.with do |connection|
+        yield connection if block_given?
+      end
+    end
+
+  end
+
+end

data/lib/hella-redis/connection_pool_spy.rb

@@ -0,0 +1,41 @@
+require 'redis'
+require 'hella-redis/connection_pool'
+require 'hella-redis/connection_spy'
+
+module HellaRedis
+
+  class ConnectionPoolSpy
+
+    attr_reader :config, :connection_spy, :connection_calls
+
+    def initialize(config)
+      @config           = config
+      @connection_spy   = ConnectionSpy.new(config)
+      @connection_calls = []
+    end
+
+    def calls
+      @connection_spy.calls
+    end
+
+    def connection(&block)
+      @connection_calls << ConnectionCall.new(block)
+      block.call(@connection_spy)
+    end
+
+    def reset!
+      @connection_calls     = []
+      @connection_spy.calls = []
+    end
+
+    def ==(other_pool_spy)
+      if other_pool_spy.kind_of?(ConnectionPoolSpy)
+        self.config == other_pool_spy.config
+      end
+    end
+
+    ConnectionCall = Struct.new(:block)
+
+  end
+
+end

data/lib/hella-redis/connection_spy.rb

@@ -1,36 +1,12 @@
 require 'redis'
-require 'hella-redis/connection'
 
 module HellaRedis
 
   class ConnectionSpy
 
-    attr_reader :config, :redis_spy, :with_calls
-
-    def initialize(config, redis_spy = nil)
-      @config     = config
-      @with_calls = []
-      @redis_spy  = redis_spy || RedisSpy.new(config)
-    end
-
-    def with(*args, &block)
-      @with_calls << WithCall.new(args, block)
-      block.call(@redis_spy)
-    end
-
-    def redis_calls
-      @redis_spy.calls
-    end
-
-  end
-
-  class RedisSpy
-
-    attr_reader :calls
+    attr_accessor :calls
 
     def initialize(config)
-      # mimic the real conection behavior, accept hash or object
-      config = Connection::Config.new(config) if config.kind_of?(::Hash)
       @instance = ::Redis.new({
         :url    => config.url,
         :driver => config.driver
@@ -39,18 +15,18 @@ module HellaRedis
     end
 
     def pipelined
-      @calls << RedisCall.new(:pipelined, [])
+      @calls << ConnectionCall.new(:pipelined, [])
       yield self
     end
 
     def multi
-      @calls << RedisCall.new(:multi, [])
+      @calls << ConnectionCall.new(:multi, [])
       yield self
     end
 
     def method_missing(name, *args, &block)
       if self.respond_to?(name)
-        @calls << RedisCall.new(name, args, block)
+        @calls << ConnectionCall.new(name, args, block)
       else
         super
       end
@@ -60,9 +36,8 @@ module HellaRedis
       super || @instance.respond_to?(*args)
     end
 
-  end
+    ConnectionCall = Struct.new(:command, :args, :block)
 
-  WithCall  = Struct.new(:args, :block)
-  RedisCall = Struct.new(:command, :args, :block)
+  end
 
 end

data/lib/hella-redis/version.rb

@@ -1,3 +1,3 @@
 module HellaRedis
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/test/support/factory.rb

@@ -1,6 +1,20 @@
 require 'assert/factory'
+require 'hella-redis'
 
 module Factory
   extend Assert::Factory
 
+  def self.config(args = nil)
+    HellaRedis::Config.new(self.config_args(args))
+  end
+
+  def self.config_args(args = nil)
+    { :timeout  => Factory.integer,
+      :size     => Factory.integer(5),
+      :redis_ns => "hella-redis-test-#{Factory.string}",
+      :url      => 'redis://localhost:6379/0',
+      :driver   => 'ruby'
+    }.merge(args || {})
+  end
+
 end

data/test/unit/connection_pool_spy_tests.rb

@@ -0,0 +1,76 @@
+require 'assert'
+require 'hella-redis/connection_pool_spy'
+
+require 'hella-redis/connection_spy'
+
+class HellaRedis::ConnectionPoolSpy
+
+  class UnitTests < Assert::Context
+    desc "HellaRedis::ConnectionPoolSpy"
+    setup do
+      Assert.stub(HellaRedis::ConnectionSpy, :new) do |*args|
+        @connection_spy_created_with = args
+        Assert.stub_send(HellaRedis::ConnectionSpy, :new, *args)
+      end
+
+      @config              = Factory.config
+      @connection_pool_spy = HellaRedis::ConnectionPoolSpy.new(@config)
+    end
+    subject{ @connection_pool_spy }
+
+    should have_readers :config, :connection_spy, :connection_calls
+    should have_imeths :calls, :connection, :reset!
+
+    should "know its config and redis spy" do
+      assert_equal @config, subject.config
+      assert_instance_of HellaRedis::ConnectionSpy, subject.connection_spy
+      exp = [@config]
+      assert_equal exp, @connection_spy_created_with
+    end
+
+    should "default its connection calls" do
+      assert_equal [], subject.connection_calls
+    end
+
+    should "know its calls" do
+      assert_same subject.connection_spy.calls, subject.calls
+    end
+
+    should "yield its connection spy using `connection`" do
+      yielded = nil
+      subject.connection{ |c| yielded = c }
+
+      assert_same subject.connection_spy, yielded
+    end
+
+    should "track calls to connection" do
+      block = proc{ |c| Factory.string }
+      subject.connection(&block)
+
+      call = subject.connection_calls.last
+      assert_equal block, call.block
+    end
+
+    should "remove all calls on `reset!`" do
+      subject.connection{ |c| c.info }
+
+      assert_not_empty subject.calls
+      assert_not_empty subject.connection_calls
+
+      subject.reset!
+
+      assert_empty subject.calls
+      assert_empty subject.connection_calls
+    end
+
+    should "know if it is equal to another pool spy" do
+      equal_pool_spy = HellaRedis::ConnectionPoolSpy.new(@config)
+      assert_equal subject, equal_pool_spy
+
+      not_equal_config = HellaRedis::ConnectionPoolSpy.new(Factory.config)
+      assert_not_equal subject, not_equal_config
+    end
+
+  end
+
+end

data/test/unit/connection_pool_tests.rb

@@ -0,0 +1,26 @@
+require 'assert'
+require 'hella-redis/connection_pool'
+
+require 'redis-namespace'
+
+class HellaRedis::ConnectionPool
+
+  class UnitTests < Assert::Context
+    desc "HellaRedis::Connection"
+    setup do
+      @connection_pool = HellaRedis::ConnectionPool.new(Factory.config)
+    end
+    subject{ @connection_pool }
+
+    should have_imeths :connection
+
+    should "build a redis namespace and yield it using `connection`" do
+      subject.connection do |connection|
+        assert_instance_of ::Redis::Namespace, connection
+        assert_nothing_raised{ connection.info }
+      end
+    end
+
+  end
+
+end

data/test/unit/connection_spy_tests.rb

@@ -4,79 +4,19 @@ require 'hella-redis/connection_spy'
 class HellaRedis::ConnectionSpy
 
   class UnitTests < Assert::Context
-    setup do
-      @config = {
-        :url    => 'redis://localhost:6379/0',
-        :driver => 'ruby'
-      }
-    end
-
-  end
-
-  class ConnectionSpyTests < UnitTests
     desc "HellaRedis::ConnectionSpy"
     setup do
-      @connection_spy = HellaRedis::ConnectionSpy.new(@config)
+      @connection_spy = HellaRedis::ConnectionSpy.new(Factory.config)
     end
     subject{ @connection_spy }
 
-    should have_readers :config, :redis_spy, :with_calls
-    should have_imeths :with, :redis_calls
-
-    should "know its config and redis spy" do
-      assert_equal @config, subject.config
-      assert_instance_of HellaRedis::RedisSpy, subject.redis_spy
-    end
-
-    should "default its with calls" do
-      assert_equal [], subject.with_calls
-    end
-
-    should "know its redis spy's calls" do
-      assert_same subject.redis_spy.calls, subject.redis_calls
-    end
-
-    should "yield its redis spy using `with`" do
-      yielded = nil
-      subject.with{ |c| yielded = c }
-      assert_same subject.redis_spy, yielded
-    end
-
-    should "track calls to with" do
-      overrides = { :timeout => Factory.integer }
-      block = proc{ |c| Factory.string }
-      subject.with(overrides, &block)
-      call = subject.with_calls.last
-      assert_equal [overrides], call.args
-      assert_equal block, call.block
-    end
-
-    should "allow passing a custom redis spy" do
-      redis_spy = Factory.string
-      spy = HellaRedis::ConnectionSpy.new(@config, redis_spy)
-      assert_equal redis_spy, spy.redis_spy
-    end
-
-  end
-
-  class RedisSpyTests < UnitTests
-    desc "HellaRedis::RedisSpy"
-    setup do
-      @redis_spy = HellaRedis::RedisSpy.new(@config)
-    end
-    subject{ @redis_spy }
-
-    should have_readers :pipelined, :multi, :calls
+    should have_accessors :calls
+    should have_imeths :pipelined, :multi
 
     should "default its calls" do
       assert_equal [], subject.calls
     end
 
-    should "allow passing a config object" do
-      config = OpenStruct.new(@config)
-      assert_nothing_raised{ HellaRedis::RedisSpy.new(config) }
-    end
-
     should "track redis calls made to it" do
       assert_true subject.respond_to?(:set)
 

data/test/unit/hella-redis_tests.rb

@@ -0,0 +1,123 @@
+require 'assert'
+require 'hella-redis'
+
+module HellaRedis
+
+  class UnitTests < Assert::Context
+    desc "HellaRedis"
+    setup do
+      @config_args = Factory.config_args
+      @module      = HellaRedis
+    end
+    subject{ @module }
+
+    should have_imeths :new, :real, :mock
+
+  end
+
+  class NewRealMockTests < UnitTests
+    setup do
+      @config = Config.new(@config_args)
+
+      @pool = ConnectionPool.new(@config)
+      @pool_new_called_with = nil
+      Assert.stub(ConnectionPool, :new) do |*args|
+        @pool_new_called_with = args
+        @pool
+      end
+
+      @pool_spy = ConnectionPoolSpy.new(@config)
+      @pool_spy_new_called_with = nil
+      Assert.stub(ConnectionPoolSpy, :new) do |*args|
+        @pool_spy_new_called_with = args
+        @pool_spy
+      end
+    end
+
+  end
+
+  class NewTests < NewRealMockTests
+    desc "`new`"
+    setup do
+      @current_test_mode = ENV['HELLA_REDIS_TEST_MODE']
+      ENV['HELLA_REDIS_TEST_MODE'] = 'yes'
+    end
+    teardown do
+      ENV['HELLA_REDIS_TEST_MODE'] = @current_test_mode
+    end
+
+    should "build and return a new connection pool" do
+      ENV.delete('HELLA_REDIS_TEST_MODE')
+      redis = subject.new(@config_args)
+
+      assert_equal [@config], @pool_new_called_with
+      assert_equal @pool, redis
+    end
+
+    should "build and return a connection pool spy in test mode" do
+      redis = subject.new(@config_args)
+
+      assert_equal [@config], @pool_spy_new_called_with
+      assert_equal @pool_spy, redis
+    end
+
+  end
+
+  class RealTests < NewRealMockTests
+    desc "`real`"
+
+    should "build and return a connection pool spy" do
+      redis = subject.real(@config_args)
+
+      assert_equal [@config], @pool_new_called_with
+      assert_equal @pool, redis
+    end
+
+  end
+
+  class MockTests < NewRealMockTests
+    desc "`mock`"
+
+    should "build and return a connection pool spy" do
+      redis = subject.mock(@config_args)
+
+      assert_equal [@config], @pool_spy_new_called_with
+      assert_equal @pool_spy, redis
+    end
+
+  end
+
+  class ConfigTests < UnitTests
+    desc "Config"
+    setup do
+      @config = Config.new(@config_args)
+    end
+    subject{ @config }
+
+    should have_readers :url, :driver, :redis_ns, :timeout, :size
+
+    should "know its attributes" do
+      assert_equal @config_args[:url],      subject.url
+      assert_equal @config_args[:driver],   subject.driver
+      assert_equal @config_args[:redis_ns], subject.redis_ns
+      assert_equal @config_args[:timeout],  subject.timeout
+      assert_equal @config_args[:size],     subject.size
+    end
+
+    should "default its size" do
+      @config_args.delete(:size)
+      config = Config.new(@config_args)
+      assert_equal 1, config.size
+    end
+
+    should "know if it is equal to another config" do
+      equal_config = Config.new(@config_args)
+      assert_equal subject, equal_config
+
+      not_equal_config = Config.new
+      assert_not_equal subject, not_equal_config
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hella-redis
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2016-06-09 00:00:00 Z
+date: 2017-04-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: assert
@@ -69,14 +69,17 @@ files:
 - README.md
 - hella-redis.gemspec
 - lib/hella-redis.rb
-- lib/hella-redis/connection.rb
+- lib/hella-redis/connection_pool.rb
+- lib/hella-redis/connection_pool_spy.rb
 - lib/hella-redis/connection_spy.rb
 - lib/hella-redis/version.rb
 - log/.gitkeep
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/connection_pool_spy_tests.rb
+- test/unit/connection_pool_tests.rb
 - test/unit/connection_spy_tests.rb
-- test/unit/connection_tests.rb
+- test/unit/hella-redis_tests.rb
 - tmp/.gitkeep
 homepage: http://github.com/redding/hella-redis
 licenses: 
@@ -100,12 +103,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: It's-a hella-redis!
 test_files: 
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/connection_pool_spy_tests.rb
+- test/unit/connection_pool_tests.rb
 - test/unit/connection_spy_tests.rb
-- test/unit/connection_tests.rb
+- test/unit/hella-redis_tests.rb

data/lib/hella-redis/connection.rb

@@ -1,35 +0,0 @@
-require 'connection_pool'
-require 'redis'
-require 'redis-namespace'
-
-module HellaRedis
-
-  module Connection
-
-    def self.new(config)
-      config = Config.new(config) if config.kind_of?(::Hash)
-      ::ConnectionPool.new(:timeout => config.timeout, :size => config.size) do
-        ::Redis::Namespace.new(config.redis_ns, {
-          :redis => ::Redis.new({
-            :url    => config.url,
-            :driver => config.driver
-          })
-        })
-      end
-    end
-
-    class Config
-      attr_reader :url, :driver, :redis_ns, :timeout, :size
-
-      def initialize(args)
-        @url      = args[:url]
-        @driver   = args[:driver]
-        @redis_ns = args[:redis_ns]
-        @timeout  = args[:timeout]
-        @size     = args[:size] || 1
-      end
-    end
-
-  end
-
-end

data/test/unit/connection_tests.rb

@@ -1,75 +0,0 @@
-require 'assert'
-require 'hella-redis/connection'
-
-require 'connection_pool'
-require 'ostruct'
-
-module HellaRedis::Connection
-
-  class UnitTests < Assert::Context
-    desc "HellaRedis::Connection"
-    setup do
-      @config_hash = {
-        :timeout  => 1,
-        :size     => 5,
-        :redis_ns => 'hella-redis-test',
-        :driver   => 'ruby',
-        :url      => 'redis://localhost:6379/0'
-      }
-      @conn = HellaRedis::Connection.new(@config_hash)
-    end
-    subject{ @conn }
-
-    should "build a connection pool" do
-      assert_instance_of ::ConnectionPool, subject
-    end
-
-    should "connect to the redis instance that was provided" do
-      assert_nothing_raised do
-        subject.with{ |c| c.info }
-      end
-    end
-
-    should "build a redis namespace and yield it using `with`" do
-      subject.with do |conn|
-        assert_instance_of ::Redis::Namespace, conn
-      end
-    end
-
-    should "allow passing a config object when building a connection" do
-      conn = nil
-      assert_nothing_raised do
-        config = OpenStruct.new(@config_hash)
-        conn = HellaRedis::Connection.new(config)
-      end
-      assert_instance_of ::ConnectionPool, conn
-    end
-
-  end
-
-  class ConfigTests < UnitTests
-    desc "Config"
-    setup do
-      @config = Config.new(@config_hash)
-    end
-    subject{ @config }
-
-    should have_readers :url, :driver, :redis_ns, :timeout, :size
-
-    should "know its attributes" do
-      assert_equal @config_hash[:url],      subject.url
-      assert_equal @config_hash[:driver],   subject.driver
-      assert_equal @config_hash[:redis_ns], subject.redis_ns
-      assert_equal @config_hash[:timeout],  subject.timeout
-      assert_equal @config_hash[:size],     subject.size
-    end
-
-    should "default its size" do
-      @config_hash.delete(:size)
-      config = Config.new(@config_hash)
-      assert_equal 1, config.size
-    end
-
-  end
-
-end