redis_fixtures 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f27c2a5df49bdb562d141a61695a64b0940c5bd0
+  data.tar.gz: 6a08100879c24423f7c071efe924acbace93d4da
+SHA512:
+  metadata.gz: 15700b8aeac3b9b3caa9287bfbbf7a672c44e23f8d4d510ad80a466fe148735e8d66ef12f154c43d42f9193c42d8f1c31b99d4c63cade46c1acb5857bb21b2e2
+  data.tar.gz: 7e5d0257945e4e13e07ac275af34da9e7edf812854e92450c1b146bca20d80f67108587b3133183c68a3f68848805b412f92619a44d4d078803077ce47870991

data/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+.idea
+*.gem
+coverage
+Gemfile.lock
+.yardoc
+doc
+test/fixtures

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.1"
+  - "2.1.5"
+
+gemfile:
+  - gemfiles/redis_3_0_0.gemfile
+  - gemfiles/redis_3_2_1.gemfile
+
+script: bundle exec rake test_with_coveralls
+
+services:
+  - redis-server

data/Appraisals

@@ -0,0 +1,7 @@
+appraise "redis-3-2-1" do
+  gem "redis", "3.2.1"
+end
+
+appraise "redis-3-0-0" do
+  gem "redis", "3.0.0"
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis_fixtures.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Daniel Magliola
+
+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,197 @@
+# redis_fixtures
+
+[![Build Status](https://travis-ci.org/dmagliola/redis_fixtures.svg?branch=master)](https://travis-ci.org/dmagliola/redis_fixtures)
+[![Coverage Status](https://coveralls.io/repos/dmagliola/redis_fixtures/badge.svg?branch=master&service=github)](https://coveralls.io/github/dmagliola/redis_fixtures?branch=master)
+[![Code Climate](https://codeclimate.com/github/dmagliola/redis_fixtures/badges/gpa.svg)](https://codeclimate.com/github/dmagliola/redis_fixtures)
+[![Inline docs](http://inch-ci.org/github/dmagliola/redis_fixtures.svg?branch=master&style=flat)](http://inch-ci.org/github/dmagliola/redis_fixtures)
+[![Gem Version](https://badge.fury.io/rb/redis_fixtures.png)](http://badge.fury.io/rb/redis_fixtures)
+[![Dependency Status](https://gemnasium.com/dmagliola/redis_fixtures.svg)](https://gemnasium.com/dmagliola/redis_fixtures)
+
+Add fixtures to your Redis database, to test the parts of your code that need Redis to be more than a cache.
+
+If you are using Redis for anything more interesting than a cache (and if you're not, get on it, Redis is awesome!),
+RedisFixtures will help you test by guaranteeing a clean, well-known state of your Redis Database at the
+start of each test.
+
+RedisFixtures is designed to integrate seamlessly with gems like [FixtureBuilder](https://github.com/rdy/fixture_builder),
+which take a snapshot of your database and dumps the data into fixture files. RedisFixtures will run at the end
+of the fixture generation phase and do exactly the same with your Redis database, dumping all the keys into a
+single fixture file. It will then reset your Redis DB to the state specified in that fixture.
+
+If you are building your fixtures manually, you can also do that, more on that below, but that sounds like a lot of
+work, I can't recommend FixtureBuilder enough to save you time, and most importantly, speed up your test suite if you're
+using tools like FactoryGirl.
+
+## Sample Use Cases / What is this good for?
+
+Here are a few situations where we're using RedisFixtures to help our tests:
+
+1. We do geo-location based on a user's IP using a Redis Sorted Set (populated with the IP ranges).
+Testing that requires having some ranges in Redis.
+
+2. We have a phone line rotation module (to be released soon) to send SMS doing a round-robin of multiple
+phone lines. That module uses Redis very heavily for performance, and we need some sample phone lines in there
+to test it.
+
+3. Our localization feature stores dynamic string translations in Redis. Again, testing this requires
+some sample translations in there.
+
+It's much more convenient to have all these as the initial well-known state of every test case, rather than
+having to set these up, particularly for our integration tests.
+
+
+## Download
+
+Gem:
+
+`gem install redis_fixtures`
+
+## Installation
+
+Load the gem in the test environment in your GemFile.
+
+  `gem "redis_fixtures", group: :test`
+
+
+## Configuration
+
+In your `test_helper.rb` file, call RedisFixtures.configure (after the setup of your Redis connection has run),
+and set how RedisFixtures should connect to Redis:
+
+```
+RedisFixtures.configure do |config|
+  # set one of :connection_pool, :connection_block, :connection_settings or :connection properties
+  config.connection_pool = $RedisPool
+end
+```
+
+You have 4 options to configure how RedisFixtures connects to your Redis database:
+
+- If you are using the [connection_pool](https://github.com/mperham/connection_pool) gem, simply set
+  `config.connection_pool = your_connection_pool`, and RedisFixtures will checkout connections from
+  the pool as needed. If you're not using connection_pool, I really recommend it, it's awesome.
+- If you already have a connection that you are reusing in your project, you can set
+  `config.connection = your_connection` and RedisFixtures will use that.
+- If you would like RedisFixtures to connect as needed, and you need some special magic to connect
+  to redis, you can use `connection_proc` to specify how to connect. For example:
+  `config.connection_proc = Proc.new{ your_magic_code_here }`. This proc should return a Redis object.
+- Or, you can simply set `connection_settings` with the connection details, like:
+  `config.connection_settings = {host: 'localhost', port: 1234}`, and RedisFixtures will connect on demand
+  by passing that object to `Redis.new`.
+- Finally, if you have a default Redis running in localhost in the default port, you don't need to set
+  anything, RedisFixtures will connect to it automatically.
+
+You can also configure the name of the fixture file generated (don't give it a .yml extension, it may get cleared
+by tools like FixtureBuilder), and the path to your app's root, if you're not using Rails.
+
+### Separate database for test
+
+It's very convenient to use a separate DB for your dev environment and your test env. For example, we use db0 for
+dev, and db1 for test. That way, running tests can reset the DB without ruining our work, if we're in the middle
+of testing something manually.
+
+Sample redis initializer to do this:
+
+```
+redis_connection = (ENV["REDISCLOUD_URL"] ? {url: ENV["REDISCLOUD_URL"]} : {host: 'localhost', port: 6379})
+redis_connection[:driver] = :hiredis
+redis_connection[:db] = 1 if Rails.env.test?
+$RedisPool = ConnectionPool.new(size: redis_pool_size, timeout: 2) do
+  Redis.new(redis_connection)
+end
+```
+
+## Generating the Fixture File
+
+There are two ways to generate the fixture file: Automagic or Manual.
+
+If you are using a tool that automatically snapshots your database into fixture files, you want to call RedisFixtures
+from it. Simply call `RedisFixtures.before_fixture_data_generation` before you generate your data into Redis, and
+`RedisFixtures.save_fixtures` afterwards, and that's it! Every time fixtures get generated, a new Redis one will
+show up.
+
+For example, you can set FixtureBuilder like this:
+
+```
+FixtureBuilder.configure do |fbuilder|
+  fbuilder.factory do
+    RedisFixtures.before_fixture_data_generation
+    SampleData.generate_test_data
+    RedisFixtures.save_fixtures
+  end
+end
+```
+
+Other fixture building tools will be similar. If you're using one of them, I'd love to see a bit of sample code
+to add here!
+
+
+### Manual Fixture Generation
+
+You can generate your Fixture manually in 2 ways:
+
+1. Actually generate the YAML file manually. The YAML file contains an array with one entry per Redis key. Each
+of those entries is an array that has several entries: The first one is the Redis command to create the key (:set, :zadd, etc),
+the second one is the key, and the rest are whatever parameters you'd pass to the Redis client to populate that key.
+
+2. A much more reasonable way is to use whatever tool you want to get Redis into the state you'd like to have it
+(I really like [RDM](http://redisdesktop.com/) for fiddling with Redis), and then call RedisFixtures.save_fixtures from
+the Rails Console (or irb, etc).
+
+But really, try to use the automagic way, it's much more convenient.
+
+
+## Running tests
+
+If you are using Minitest, you're done! RedisFixtures will automatically reset your Redis DB to a known state before
+each test.
+
+If you are using RSpec... This is a great opportunity for you to submit a Pull Request! No, in all seriousness, I have plans
+to add RSpec integration, but it may be easier for someone more experienced with RSpec.
+
+
+## Version Compatibility and Continuous Integration
+
+Tested with [Travis](https://travis-ci.org/dmagliola/redis_fixtures) using Ruby 1.9.3, 2.0, 2.1.1 and 2.1.5,
+ and against redis 3.0.0 and 3.2.1.
+
+To locally run tests do:
+
+```
+appraisal rake test
+```
+
+## Copyright
+
+Copyright (c) 2015, Daniel Magliola
+
+See LICENSE for details.
+
+
+## Users
+
+This gem is being used by:
+
+- [MSTY](https://www.msty.com)
+- You? please, let us know if you are using this gem.
+
+
+## Changelog
+
+### Version 1.0.0 (Oct 8th, 2015)
+- Newly released gem
+
+## Contributing
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. Code your thing
+1. Write and run tests:
+        bundle install
+        appraisal
+        appraisal rake test
+1. Write documentation and make sure it looks good: yard server --reload
+1. Add items to the changelog, in README.
+1. Commit your changes (`git commit -am "Add some feature"`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Create new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+require "rubygems"
+require "bundler/setup"
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test
+
+require 'coveralls/rake/task'
+Coveralls::RakeTask.new
+task :test_with_coveralls => ["test", "coveralls:push"]

data/gemfiles/redis_3_0_0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "3.0.0"
+
+gemspec :path => "../"

data/gemfiles/redis_3_0_0.gemfile.lock

@@ -0,0 +1,94 @@
+PATH
+  remote: ../
+  specs:
+    redis_fixtures (1.0.0)
+      redis (>= 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    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)
+    ansi (1.5.0)
+    appraisal (2.1.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    builder (3.2.2)
+    codeclimate-test-reporter (0.4.8)
+      simplecov (>= 0.7.1, < 1.0.0)
+    connection_pool (2.2.0)
+    coveralls (0.8.3)
+      json (~> 1.8)
+      rest-client (>= 1.6.8, < 2)
+      simplecov (~> 0.10.0)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+    docile (1.1.5)
+    domain_name (0.5.24)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    metaclass (0.0.4)
+    mime-types (2.6.2)
+    minitest (5.8.1)
+    minitest-reporters (1.1.2)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    mocha (1.1.0)
+      metaclass (~> 0.0.1)
+    netrc (0.10.3)
+    rake (10.4.2)
+    redis (3.0.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    ruby-progressbar (1.7.5)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.2.1)
+    shoulda-matchers (2.8.0)
+      activesupport (>= 3.0.0)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tins (1.6.0)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appraisal
+  bundler
+  codeclimate-test-reporter
+  connection_pool
+  coveralls
+  minitest
+  minitest-reporters
+  mocha
+  rake
+  redis (= 3.0.0)
+  redis_fixtures!
+  shoulda
+  simplecov

data/gemfiles/redis_3_2_1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "3.2.1"
+
+gemspec :path => "../"

data/gemfiles/redis_3_2_1.gemfile.lock

@@ -0,0 +1,94 @@
+PATH
+  remote: ../
+  specs:
+    redis_fixtures (1.0.0)
+      redis (>= 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    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)
+    ansi (1.5.0)
+    appraisal (2.1.0)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    builder (3.2.2)
+    codeclimate-test-reporter (0.4.8)
+      simplecov (>= 0.7.1, < 1.0.0)
+    connection_pool (2.2.0)
+    coveralls (0.8.2)
+      json (~> 1.8)
+      rest-client (>= 1.6.8, < 2)
+      simplecov (~> 0.10.0)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+    docile (1.1.5)
+    domain_name (0.5.24)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    metaclass (0.0.4)
+    mime-types (2.6.2)
+    minitest (5.8.1)
+    minitest-reporters (1.1.2)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    mocha (1.1.0)
+      metaclass (~> 0.0.1)
+    netrc (0.10.3)
+    rake (10.4.2)
+    redis (3.2.1)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    ruby-progressbar (1.7.5)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.2.1)
+    shoulda-matchers (2.8.0)
+      activesupport (>= 3.0.0)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tins (1.6.0)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appraisal
+  bundler
+  codeclimate-test-reporter
+  connection_pool
+  coveralls
+  minitest
+  minitest-reporters
+  mocha
+  rake
+  redis (= 3.2.1)
+  redis_fixtures!
+  shoulda
+  simplecov

data/lib/redis_fixtures.rb

@@ -0,0 +1,10 @@
+require 'redis_fixtures/config'
+require 'redis_fixtures/connection'
+require 'redis_fixtures/dump_fixtures'
+require 'redis_fixtures/load_fixtures'
+require 'redis_fixtures/minitest'
+require 'redis_fixtures/version'
+
+# Add fixtures to your Redis database, to test the parts of your code that need Redis to be more than a cache.
+module RedisFixtures
+end

data/lib/redis_fixtures/config.rb

@@ -0,0 +1,71 @@
+module RedisFixtures
+  # Thrown when a config setting is invalid
+  class InvalidConfigSettingError < StandardError; end
+
+  # Holds the configuration
+  class Configuration
+    # Root directory of the app (where the test or spec directory exists)
+    # Defaults to Rails.root or `pwd`, use only if using this gem in a non-Rails environment
+    attr_accessor :app_root
+
+    # Filename where to store the Redis fixtures. (Will be stored in regular fixtures path)
+    # Defaults to 'redis.fixture'
+    # Do not set a .yml extension, or it may get cleared out by other tools
+    attr_accessor :fixture_filename
+
+    # Connection Pool used to get a new Redis connection
+    # One of :connection_pool, :connection_block, :connection_settings or :connection must be set
+    attr_accessor :connection_pool
+
+    # Proc that yields a connection object when needed
+    # One of :connection_pool, :connection_block, :connection_settings or :connection must be set
+    attr_accessor :connection_proc
+
+    # Hash specifying the settings to connect to Redis. Gets passed to `Redis.new`
+    # One of :connection_pool, :connection_block, :connection_settings or :connection must be set
+    # Defaults to localhost:6379
+    attr_accessor :connection_settings
+
+    # Already established connection to Redis for the library to use
+    # One of :connection_pool, :connection_block, :connection_settings or :connection must be set
+    attr_accessor :connection
+
+    def initialize
+      @connection_settings = {host: 'localhost', port: 6379}
+      @fixture_filename = "redis.fixture"
+      @app_root = defined?(::Rails) ? ::Rails.root : Dir.pwd
+    end
+  end
+
+  # Returns the current configuration
+  # @return [Configuration] the configuration class
+  def self.configuration
+    @configuration ||=  Configuration.new
+  end
+
+  # Yields the current configuration, allowing the caller to modify it in a block
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
+  # Path to the file where we'll store Redis fixtures
+  # @return [String]
+  def self.fixture_file_path
+    fixtures_dir(RedisFixtures.configuration.fixture_filename)
+  end
+
+  private
+
+  # Full path to where Fixtures are stored, or to a file inside the fixtures directory
+  # @param path [Symbol] path to resolve inside of the fixtures directory
+  # @return [String] "{your_app}/(spec|test)/fixtures/{path}"
+  def self.fixtures_dir(path = '')
+    File.expand_path(File.join(RedisFixtures.configuration.app_root, spec_or_test_dir, 'fixtures', path))
+  end
+
+  # Directory where specs or tests are stored
+  # @return [String] 'spec' or 'test'
+  def self.spec_or_test_dir
+    File.exists?(File.join(RedisFixtures.configuration.app_root, 'spec')) ? 'spec' : 'test'
+  end
+end

data/lib/redis_fixtures/connection.rb

@@ -0,0 +1,23 @@
+module RedisFixtures
+  # Gets a connection to Redis using whatever method was configured,
+  # and yields it to the block passed in
+  # @return [Object] Whatever your block returned
+  def self.with_redis_connection
+    result = nil
+    conf = RedisFixtures.configuration
+    if conf.connection_pool.present?
+      conf.connection_pool.with do |redis|
+        result = yield(redis)
+      end
+    elsif conf.connection.present?
+      result = yield(conf.connection)
+    elsif conf.connection_proc.present? || conf.connection_settings.present?
+      redis = conf.connection_proc.present? ?
+                conf.connection_proc.call :
+                Redis.new(conf.connection_settings)
+      result = yield(redis)
+      redis.disconnect! if redis.respond_to?(:disconnect!)
+    end
+    result
+  end
+end

data/lib/redis_fixtures/dump_fixtures.rb

@@ -0,0 +1,94 @@
+module RedisFixtures
+  # Cleans up the Redis DB. Call this before starting your sample data generation
+  # to start with a clean slate
+  def self.before_fixture_data_generation
+    with_redis_connection do |redis|
+      redis.flushdb
+    end
+  end
+
+  # Dumps the contents of the Redis DB into a fixture file.
+  # Call this after generating all your sample data in Redis.
+  def self.save_fixtures
+    redis_dump = with_redis_connection do |redis|
+      dump_keys(redis)
+    end
+    FileUtils.mkdir_p(fixtures_dir) unless File.directory?(fixtures_dir)
+    File.open(fixture_file_path, 'w') { |file| file.write(redis_dump.to_yaml) }
+  end
+
+  private
+
+  # Finds all the keys in the Redis Database and dumps them into an array of arrays
+  # that can then be used to easily reconstruct the data
+  #
+  # @param redis [Redis] Redis connection
+  # @return [Array of `commands`] an array of arrays, one entry per key, each of which
+  # can be used to execute a redis call that will create and populate the key in Redis.
+  def self.dump_keys(redis)
+    keys = redis.keys("*")
+    keys.map do |key|
+      key_type = redis.type(key)
+      case key_type
+        when "hash"
+          dump_hash(redis, key)
+        when "zset"
+          dump_zset(redis, key)
+        when "list"
+          dump_list(redis, key)
+        when "set"
+          dump_set(redis, key)
+        when "string" # HLL's are stored internally as strings
+          dump_string(redis, key)
+        else
+          raise "Don't know how to dump a fixture for Redis type: #{key_type} (key: #{key})" # Should never happen, these are all the types Redis can return
+      end
+    end
+  end
+
+  # Dump a Redis Hash into a `command` that will allows us to regenerate it
+  # @param redis [Redis] Redis connection
+  # @param key [String] the key to dump
+  # @return [Array] an array specifying a `mapped_hmset` command, the key, and the hash to store in Redis
+  def self.dump_hash(redis, key)
+    hash = redis.hgetall(key)
+    [:mapped_hmset, key, hash]
+  end
+
+  # Dump a Redis Sorted Set into a `command` that will allows us to regenerate it
+  # @param redis [Redis] Redis connection
+  # @param key [String] the key to dump
+  # @return [Array] an array specifying a `zadd` command, the key, and the values and scores to store in Redis
+  def self.dump_zset(redis, key)
+    zset = redis.zrange key, 0, -1, with_scores: true
+    zset = zset.map{|entry| entry.reverse} # Zrange returns [["a", 32.0], ["b", 64.0]]. Zadd wants [[32.0, "a"], [64.0, "b"]]
+    [:zadd, key, zset]
+  end
+
+  # Dump a Redis List into a `command` that will allows us to regenerate it
+  # @param redis [Redis] Redis connection
+  # @param key [String] the key to dump
+  # @return [Array] an array specifying a `rpush` command, the key, and the values and scores to store in Redis
+  def self.dump_list(redis, key)
+    list = redis.lrange key, 0, -1
+    [:rpush, key, list]
+  end
+
+  # Dump a Redis Set into a `command` that will allows us to regenerate it
+  # @param redis [Redis] Redis connection
+  # @param key [String] the key to dump
+  # @return [Array] an array specifying a `sadd` command, the key, and the values and scores to store in Redis
+  def self.dump_set(redis, key)
+    set = redis.smembers key
+    [:sadd, key, set]
+  end
+
+  # Dump a Redis String into a `command` that will allows us to regenerate it
+  # This also covers HyperLogLogs and Bitmaps.
+  # @param redis [Redis] Redis connection
+  # @param key [String] the key to dump
+  # @return [Array] an array specifying a `set` command, the key, and the string to store in Redis
+  def self.dump_string(redis, key)
+    [:set, key, redis.get(key)]
+  end
+end

data/lib/redis_fixtures/load_fixtures.rb

@@ -0,0 +1,15 @@
+module RedisFixtures
+  # Load the Redis fixture YAML file, into Redis, flushing the DB first
+  def self.load_fixtures
+    return unless File.exists?(fixture_file_path)
+    commands = YAML.load_file(fixture_file_path)
+    with_redis_connection do |redis|
+      redis.pipelined do |predis|
+        predis.flushdb
+        commands.each do |command|
+          predis.send(*command)
+        end
+      end
+    end
+  end
+end

data/lib/redis_fixtures/minitest.rb

@@ -0,0 +1,13 @@
+# Module to set a before_setup Minitest hook, to reset Redis to the state specified by the fixture
+# before each test runs
+module MinitestRedisFixtures
+  # Clear Redis DB and load the fixture before the setup step of each test
+  def before_setup
+    super
+    RedisFixtures.load_fixtures
+  end
+end
+
+class MiniTest::Test
+  include MinitestRedisFixtures
+end

data/lib/redis_fixtures/version.rb

@@ -0,0 +1,3 @@
+module RedisFixtures
+  VERSION = "1.0.0"
+end

data/redis_fixtures.gemspec

@@ -0,0 +1,43 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "redis_fixtures/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'redis_fixtures'
+  s.version     = RedisFixtures::VERSION
+  s.summary     = "Add fixtures to your Redis database, to test the parts of your code that need Redis to be more than a cache."
+  s.description = %q{RedisFixtures allows you to have fixtures for Redis, in addition to the ones for your database.
+                       If you are using Redis as more than just a cache (and I hope you are), you probably need to have
+                       some data there to test your application. RedisFixtures will reset your (test) Redis database
+                       at the beginning of every test to the fixture you set.
+                       And if you use FixtureBuilder (or any other fixture-generating library), you can automatically
+                       generate your Redis fixture from the contents of your test Redis database.
+                   }
+  s.authors     = ["Daniel Magliola"]
+  s.email       = 'dmagliola@crystalgears.com'
+  s.homepage    = 'https://github.com/dmagliola/redis_fixtures'
+  s.license     = 'MIT'
+
+  s.files       = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|s.features)/})
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 1.9.3"
+
+  s.add_runtime_dependency "redis", '>= 3.0'
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "minitest-reporters"
+  s.add_development_dependency "shoulda"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "simplecov"
+
+  s.add_development_dependency "appraisal"
+  s.add_development_dependency "coveralls"
+  s.add_development_dependency "codeclimate-test-reporter"
+  s.add_development_dependency "connection_pool"
+end

data/test/connection_test.rb

@@ -0,0 +1,63 @@
+require_relative "test_helper"
+
+class ConnectionTest < MiniTest::Test
+  context "with resetting of configuration" do
+    setup do
+      TestResetHelper.reset_configuration
+    end
+
+    teardown do
+      TestResetHelper.reset_configuration
+    end
+
+    should "connect using a connection pool" do
+      redis_pool = ::ConnectionPool.new(size: 2, timeout: 2) do
+        Redis.new($RedisConnectionSettings)
+      end
+
+      RedisFixtures.configure do |config|
+        config.connection_pool = redis_pool
+        config.connection_settings = {host: 'localhost', port: 1111} # Just to make sure it's not using this
+      end
+
+      test_connection
+    end
+
+    should "connect using a connection proc" do
+      RedisFixtures.configure do |config|
+        config.connection_proc = Proc.new{ Redis.new($RedisConnectionSettings) }
+        config.connection_settings = {host: 'localhost', port: 1111} # Just to make sure it's not using this
+      end
+
+      test_connection
+    end
+
+    should "connect using an existing connection" do
+      conn = Redis.new($RedisConnectionSettings)
+
+      RedisFixtures.configure do |config|
+        config.connection = conn
+        config.connection_settings = {host: 'localhost', port: 1111} # Just to make sure it's not using this
+      end
+
+      test_connection
+    end
+
+    should "connect using default connection settings" do
+      RedisFixtures.configure do |config|
+        config.connection_settings = {host: 'localhost', port: 6379} # Just to make sure it's not using this
+      end
+
+      test_connection
+    end
+  end
+
+  private
+
+  def test_connection
+    RedisFixtures.with_redis_connection do |redis|
+      redis.set "aaa", "bbb"
+      assert_equal "bbb", redis.get("aaa")
+    end
+  end
+end

data/test/dump_fixtures_test.rb

@@ -0,0 +1,56 @@
+require_relative "test_helper"
+
+class DumpFixturesTest < MiniTest::Test
+  should "dump fixtures" do
+    begin
+      # Check that we start with the normal keys
+      RedisFixtures.with_redis_connection do |redis|
+        assert_equal ["string_key"], redis.keys("*")
+      end
+
+      # Set some new data in Redis
+      commands = [
+        [:mapped_hmset, "hash1", {"a" => "1", "b" => "2", "c" => "3"}],
+        [:zadd, "zset1", [[32.0, "a"], [64.0, "b"]]],
+        [:rpush, "list1", ["3", "4", "5", "6"]],
+        [:sadd, "set1", ["3", "4", "5", "6"]],
+        [:set, "string1", "thestring!"],
+      ]
+      keys = commands.map{|cmd| cmd[1]}
+
+      RedisFixtures.with_redis_connection do |redis|
+        redis.flushdb
+        commands.each do |cmd|
+          redis.send(*cmd)
+        end
+
+        # Check that the keys are there
+        assert_equal keys.sort, redis.keys("*").sort
+      end
+
+      RedisFixtures.save_fixtures
+
+      # Check the YAML file
+      serialized_commands = YAML.load_file(RedisFixtures.fixture_file_path)
+      assert_equal commands.sort_by{|cmd| cmd[1]}, serialized_commands.sort_by{|cmd| cmd[1]}
+    rescue
+    ensure
+      TestResetHelper.reset_fixtures_file_and_db
+    end
+  end
+
+  should "clear DB before fixture generation" do
+    RedisFixtures.before_fixture_data_generation
+    RedisFixtures.with_redis_connection do |redis|
+      assert_equal [], redis.keys("*")
+    end
+  end
+
+  should "raise an exception if it finds a strange key type in Redis" do
+    # This can't actually happen, but it's future proofing. Thus, we need to mock.
+    Redis.any_instance.expects(:type).returns("unknown_type")
+    assert_raises RuntimeError do
+      RedisFixtures.save_fixtures
+    end
+  end
+end

data/test/load_fixtures_test.rb

@@ -0,0 +1,32 @@
+require_relative "test_helper"
+
+class LoadFixturesTest < MiniTest::Test
+  should "load fixtures" do
+    begin
+      # Generate a new fixtures file
+      commands = [
+        [:zadd, "zset1", [[32.0, "a"], [64.0, "b"]]],
+        [:rpush, "list1", ["3", "4", "5", "6"]],
+        [:set, "string1", "thestring!"],
+      ]
+      File.open(RedisFixtures.fixture_file_path, 'w') { |file| file.write(commands.to_yaml) }
+
+      # Check that we start with the normal keys
+      RedisFixtures.with_redis_connection do |redis|
+        assert_equal ["string_key"], redis.keys("*")
+      end
+
+      RedisFixtures.load_fixtures
+
+      # Check that we have these new keys in the DB
+      RedisFixtures.with_redis_connection do |redis|
+        assert_equal ["zset1", "list1", "string1"].sort, redis.keys("*").sort
+        assert_equal ["3", "4", "5", "6"], redis.lrange("list1", 0, -1)
+        assert_equal ["a", "b"], redis.zrange("zset1", 0, -1)
+      end
+    rescue
+    ensure
+      TestResetHelper.reset_fixtures_file_and_db
+    end
+  end
+end

data/test/minitest_hook_test.rb

@@ -0,0 +1,12 @@
+require_relative "test_helper"
+
+class MinitestHookTest < MiniTest::Test
+  should "have cleaned the database and loaded the fixtures" do
+    # Test helper left the DB with one key called "delete_me", and the fixture says there's one string called "string_key"
+    # When the test runs, the DB should reflect the fixture
+    RedisFixtures.with_redis_connection do |redis|
+      keys = redis.keys("*")
+      assert_equal ["string_key"], keys
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,67 @@
+require "rubygems"
+
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter "/test/"
+  add_filter "/gemfiles/vendor"
+end
+
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require "minitest/autorun"
+require "minitest/reporters"
+MiniTest::Reporters.use!
+
+require "shoulda"
+require "shoulda-context"
+require "shoulda-matchers"
+require "mocha/setup"
+
+# Make the code to be tested easy to load.
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'active_support/testing/assertions'
+include ActiveSupport::Testing::Assertions
+
+require "benchmark"
+
+require "redis_fixtures"
+require "redis"
+require "connection_pool"
+
+
+# Add helper methods to use in the tests
+$RedisConnectionSettings = {host: 'localhost', port: 6379, db: 2}
+
+class TestResetHelper
+  def self.reset_configuration
+    RedisFixtures.instance_variable_set(:@configuration, RedisFixtures::Configuration.new)
+    RedisFixtures.configure do |config|
+      config.connection_settings = $RedisConnectionSettings
+    end
+  end
+
+  def self.reset_fixtures_file_and_db
+    reset_configuration
+    RedisFixtures.with_redis_connection do |redis|
+      redis.flushdb
+      redis.set("string_key", "blah")
+      RedisFixtures.save_fixtures
+      redis.flushdb
+      redis.set("delete_me", "aa")
+    end
+  end
+end
+
+
+# Prepare some test data, before tests run, since we're testing a "before_setup" hook
+TestResetHelper.reset_configuration
+TestResetHelper.reset_fixtures_file_and_db
+

metadata

@@ -0,0 +1,249 @@
+--- !ruby/object:Gem::Specification
+name: redis_fixtures
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Daniel Magliola
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "RedisFixtures allows you to have fixtures for Redis, in addition to
+  the ones for your database.\n                       If you are using Redis as more
+  than just a cache (and I hope you are), you probably need to have\n                       some
+  data there to test your application. RedisFixtures will reset your (test) Redis
+  database\n                       at the beginning of every test to the fixture you
+  set.\n                       And if you use FixtureBuilder (or any other fixture-generating
+  library), you can automatically\n                       generate your Redis fixture
+  from the contents of your test Redis database.\n                   "
+email: dmagliola@crystalgears.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Appraisals
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- gemfiles/redis_3_0_0.gemfile
+- gemfiles/redis_3_0_0.gemfile.lock
+- gemfiles/redis_3_2_1.gemfile
+- gemfiles/redis_3_2_1.gemfile.lock
+- lib/redis_fixtures.rb
+- lib/redis_fixtures/config.rb
+- lib/redis_fixtures/connection.rb
+- lib/redis_fixtures/dump_fixtures.rb
+- lib/redis_fixtures/load_fixtures.rb
+- lib/redis_fixtures/minitest.rb
+- lib/redis_fixtures/version.rb
+- redis_fixtures.gemspec
+- test/connection_test.rb
+- test/dump_fixtures_test.rb
+- test/load_fixtures_test.rb
+- test/minitest_hook_test.rb
+- test/test_helper.rb
+homepage: https://github.com/dmagliola/redis_fixtures
+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
+signing_key: 
+specification_version: 4
+summary: Add fixtures to your Redis database, to test the parts of your code that
+  need Redis to be more than a cache.
+test_files:
+- test/connection_test.rb
+- test/dump_fixtures_test.rb
+- test/load_fixtures_test.rb
+- test/minitest_hook_test.rb
+- test/test_helper.rb
+has_rdoc: