mock_redis_lua_extension 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c9ac03c2745ae7cf81444d9b5d92ec76be1685ecd99806037152d18e8bf2d66
+  data.tar.gz: b2d472940117687fded0d9cdf63b882390a0a5cdab767912fe82db371f110499
+SHA512:
+  metadata.gz: cd745df3ac161d1f1fce18febcb482ac499032bc83c6d74195b5d695422b5549b24747b047cd788a521abe98245a4726c644a81ec33049199f994949cc292575
+  data.tar.gz: f2a7a673f36e0bd347cb57ef66a95fbbacfd5eba68e5e606401502375c7e8111f320de11cdeba360e32de91fed4737aaeb7af1b619d266dd00d31f2d5c1dacd0

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'pry'
+  gem 'rake',  '~> 11.0'
+  gem 'rspec', '~> 3.0'
+end

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    mock_redis_lua_extension (0.2.0)
+      mock_redis
+      rufus-lua
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    ffi (1.9.25)
+    method_source (0.9.0)
+    mock_redis (0.19.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (11.3.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    rufus-lua (1.1.5)
+      ffi (~> 1.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mock_redis_lua_extension!
+  pry
+  rake (~> 11.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Invoca
+
+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,2 @@
+# mock_redis_lua_extension
+Extension to mock_redis enabling lua execution via rufus-lua

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  puts 'No Rspec available'
+end

data/lib/mock_redis_lua_extension.rb

@@ -0,0 +1,273 @@
+begin
+  require 'rufus-lua'
+  RUFUS_LUA_LOADED = true
+rescue StandardError => ex
+  RUFUS_LUA_LOADED = false
+  STDERR.puts "Failed to load rufus-lua: Exception was #{ex.inspect}"
+end
+
+require 'json'
+require 'digest'
+
+module MockRedisLuaExtension
+  class InvalidCommand < StandardError; end
+  class InvalidDataType < StandardError; end
+
+  LIMIT_CMDS = [
+    'zrangebyscore',
+    'zrangebylex',
+    'zrevrangebyscore',
+    'zrevrangebylex'
+  ].freeze
+
+  WITHSCORES_CMDS = [
+    'zrange',
+    'zrangebyscore',
+    'zrevrangebyscore'
+  ].freeze
+
+  def self.wrap(instance)
+    if !instance.respond_to?(:mock_redis_lua_extension_enabled) && is_a_mock?(instance)
+      class << instance
+        if RUFUS_LUA_LOADED
+          prepend(MockRedisLuaExtension)
+        end
+      end
+    elsif !is_a_mock?(instance)
+      raise ArgumentError, 'Can only wrap MockRedis instances'
+    end
+    instance
+  end
+
+  def self.is_a_mock?(instance)
+    instance.class.ancestors.any? { |a| a.to_s == 'MockRedis' }
+  end
+
+  def mock_redis_lua_extension_enabled
+    RUFUS_LUA_LOADED
+  end
+
+  def script(subcmd, *args)
+    case subcmd.downcase.to_sym
+    when :load
+      args.count == 1 or raise ArgumentError, "Invalid args: #{args.inspect}"
+      script = args.first
+      Digest::SHA256.hexdigest(script).tap do |sha|
+        script_catalog[sha] = script
+      end
+    when :flush
+      @script_catalog = {}
+      true
+    when :exists
+      args = args.first
+      if args.is_a?(Array)
+        args.map { |sha| script_catalog.include?(sha) }
+      else
+        script_catalog.include?(args)
+      end
+    else
+      raise ArgumentError, "Invalid script command: #{subcmd}"
+    end
+  end
+
+  def evalsha(sha, keys=nil, argv=nil, **args)
+    if script(:exists, sha)
+      eval(script_catalog[sha], keys, argv, **args)
+    else
+      raise ArgumentError, "NOSCRIPT No matching script. Please use EVAL."
+    end
+  end
+
+  def eval(script, keys=nil, argv=nil, **args)
+    lua_state = Rufus::Lua::State.new
+    setup_keys_and_argv(lua_state, keys, argv, args)
+
+    lua_state.function 'redis.call' do |cmd, *args|
+      lua_bound_redis_call(cmd, *args)
+    end
+
+    lua_state.function 'redis.breakpoint' do
+      # Use redis commands such as `self.hgetall("key")` to debug
+      binding.pry
+    end
+
+    lua_state.function 'redis.debug' do |*args|
+      parsed_args = args.map { |arg| arg.is_a?(Rufus::Lua::Table) ? arg.to_ruby : arg }
+      puts parsed_args.map(&:to_s).join(", ")
+    end
+
+    lua_state.function 'cjson.decode' do |arg|
+      lua_bound_cjson_decode(arg)
+    end
+
+    lua_state.function 'cjson.encode' do |arg|
+      lua_bound_cjson_encode(arg)
+    end
+    marshal_lua_return_to_ruby(lua_state.eval(script))
+  end
+
+  private
+
+  def script_catalog
+    @script_catalog ||= {}
+  end
+
+  def lua_bound_redis_call(cmd, *args)
+    cmd = cmd.downcase
+    if valid_lua_bound_cmds.include?(cmd.to_sym)
+      redis_call_from_lua(cmd, *args)
+    else
+      raise InvalidCommand, "Invalid command (cmd: #{cmd}, args: #{args.inspect})"
+    end
+  rescue InvalidDataType => ex
+    raise InvalidCommand, "Invalid command (cmd: #{cmd}, args: #{args.inspect}) caused by #{ex.class}(#{ex.message})"
+  end
+
+  def lua_bound_cjson_decode(arg)
+    JSON.parse(arg)
+  end
+
+  def lua_bound_cjson_encode(arg)
+    case arg
+    when String, Float, Integer, NilClass
+      arg.to_json
+    when Rufus::Lua::Table
+      table_to_array_or_hash(arg).to_json
+    else
+      raise InvalidDataType, "Unexpected data type for cjson.encode: #{arg.inspect}"
+    end
+  end
+
+  def setup_keys_and_argv(lua_state, keys, argv, args)
+    keys = [] unless keys
+    keys = args[:keys] if args[:keys]
+
+    argv = [] unless argv
+    argv = args[:argv] if args[:argv]
+
+    lua_state['KEYS'] = keys.map { |k| k.to_s }
+    lua_state['ARGV'] = argv.map { |a| a.to_s }
+  end
+
+  def redis_call_from_lua(cmd, *args)
+    redis_args = marshal_lua_args_to_redis(cmd, args)
+    redis_result = self.send(cmd, *redis_args)
+    marshal_redis_result_to_lua(redis_result, flatten_array: WITHSCORES_CMDS.include?(cmd.downcase))
+  end
+
+  def marshal_lua_args_to_redis(cmd, args)
+    options, args = parse_options(cmd, args)
+    converted_args = args.map do |arg|
+      case arg
+      when Float, Integer
+        arg.to_s
+      when String
+        arg
+      else
+        raise InvalidDataType, "Lua redis() command arguments must be strings or numbers (was: #{args.inspect})"
+      end
+    end
+    if options.any? { |_, v| v }
+      converted_args + [options]
+    else
+      converted_args
+    end
+  end
+
+  def parse_options(cmd, args)
+    limit, args = if args[-3].to_s.downcase == 'limit' && LIMIT_CMDS.include?(cmd)
+             [args[-2..-1], args[0...-3]]
+           else
+             [nil, args]
+           end
+
+    withscores, args = if args[-1].to_s.downcase == 'withscores' && WITHSCORES_CMDS.include?(cmd)
+                         [true, args[0...-1]]
+                       else
+                         [nil, args]
+                       end
+
+    return { limit: limit, with_scores: withscores }, args
+  end
+
+  def marshal_redis_result_to_lua(result, **options)
+    case result
+    when nil
+      false
+    when true
+      1
+    when false
+      0
+    when Array
+      options[:flatten_array] ? result.flatten : result
+    when Integer, String
+      result
+    when Float
+      result.to_s
+    else
+      raise InvalidDataType, "Unsupported type returned from redis (was: #{result.inspect})"
+    end
+  end
+
+  def marshal_lua_return_to_ruby(arg)
+    case arg
+    when false
+      nil
+    when true
+      1
+    when Float, Integer
+      arg.to_i
+    when String, Array, nil
+      arg
+    when Rufus::Lua::Table
+      table_to_array_or_status(arg)
+    else
+      raise InvalidDataType, "Unsupported type returned from script (was: #{arg.inspect})"
+    end
+  end
+
+  def table_to_array_or_status(table)
+    (1..table.keys.length).map do |i|
+      marshal_lua_return_to_ruby(table[i.to_f])
+    end.compact
+  end
+
+  def table_to_array_or_hash(table)
+    if table.keys.all? { |k| k.is_a?(Numeric) && k >=0 }
+      table.to_a
+    else
+      table.to_h
+    end
+  end
+
+  def valid_lua_bound_cmds
+    @valid_lua_bound_cmds ||= Hash[[
+        #Hash commands
+        :hdel, :hexists, :hget, :hgetall, :hincrby, :hincrbyfloat, :hkeys, :hlen,
+        :hmget, :hmset, :hset, :hsetnx, :hstrlen, :hvals, :hscan,
+
+        #Key commands
+        :del, :dump, :exists, :expire, :expireat, :keys, :persist, :pexpire, :pexpireat,
+        :pttl, :randomkey, :rename, :renamenx, :sort, :touch, :ttl, :type, :unlink,
+
+        #List commands
+        :blpop, :brpop, :brpoplpush, :lindex, :linsert, :llen, :lpop, :lpush, :lpushx,
+        :lrange, :lrem, :lset, :ltrim, :rpop, :rpoplpush, :rpush, :rpushx,
+
+        #Set commands
+        :sadd, :scard, :sdiff, :sdiffstore, :sinter, :sinterstore, :sismember, :smembers,
+        :smove, :spop, :srandmember, :srem, :sunion, :sunionstore, :sscan,
+
+        #SortedSet commands
+        :zadd, :zcard, :zcount, :zincrby, :zinterstore, :zlexcount, :zrange, :zrangebylex,
+        :zrevrangebylex, :zrangebyscore, :zrank, :zrem, :zremrangebylex, :zremrangebyrank,
+        :zremrangebyscore, :zrevrange, :zrevrangebyscore, :zrevrank, :zscore, :zunionstore,
+        :zscan,
+
+        #String commands
+        :append, :bitcount, :bitfield, :bitop, :bitpos, :decr, :decrby, :get, :getbit,
+        :getrange, :getset, :incr, :incrby, :incrbyfloat, :mget, :mset, :msetnx, :psetex,
+        :set, :setbit, :setex, :setnx, :setrange, :strlen
+    ].map {|cmd| [cmd, true] }]
+  end
+end

data/lib/mock_redis_lua_extension/version.rb

@@ -0,0 +1,3 @@
+module MockRedisLuaExtension
+  VERSION = "0.2.0".freeze
+end

data/mock_redis_lua_extension.gemspec

@@ -0,0 +1,20 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+require "mock_redis_lua_extension/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "mock_redis_lua_extension"
+  s.version     = MockRedisLuaExtension::VERSION
+  s.authors     = ["Chad Simmons"]
+  s.email       = ["csimmons@invoca.com"]
+  s.homepage    = "https://github.com/Invoca/mock_redis_lua_extension"
+  s.summary     = "Extension to mock_redis enabling lua execution via rufus-lua"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_dependency 'mock_redis'
+  s.add_dependency 'rufus-lua'
+end

data/spec/mock_redis_lua_extension_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+require 'mock_redis_lua_extension'
+require 'mock_redis'
+
+require 'pry'
+
+RSpec.describe MockRedisLuaExtension, '::' do
+
+  let(:redis) { MockRedisLuaExtension.wrap(MockRedis.new) }
+
+  context 'extending a MockRedis instance' do
+    it 'should add a method indicating that the MockRedis has been extended' do
+      expect(redis.respond_to?(:mock_redis_lua_extension_enabled)).to eq(true)
+    end
+
+    it 'should raise an ArgumentError when attempting to wrap an object that is not a MockRedis' do
+      expect { MockRedisLuaExtension.wrap(Object.new) }.to raise_error(ArgumentError,
+                                                                       'Can only wrap MockRedis instances')
+    end
+
+    it 'supports eval with redis bound to self' do
+      redis.hset('myhash', 'field', 5)
+      lua_script = %q|
+            redis.call('hincrby', KEYS[1], ARGV[1], ARGV[2])
+      |.strip
+      redis.eval(lua_script, keys: ['myhash'], argv: ['field', 2])
+      value = redis.hget('myhash', 'field')
+      expect(value).to eq('7')
+    end
+
+    it 'supports the script command to load scripts for use with evalsha' do
+      sha = redis.script(:load, 'return "EXECUTED"')
+      expect(redis.evalsha(sha)).to eq('EXECUTED')
+    end
+
+    it 'supports script exists' do
+      sha = redis.script(:load, 'return "EXECUTED"')
+      expect(redis.script(:exists, sha)).to eq(true)
+
+      expect(redis.script(:exists, '1114444')).to eq(false)
+    end
+
+    it 'supports script exists with multiple shas' do
+      sha1 = redis.script(:load, 'return "EXECUTED"')
+      sha2 = redis.script(:load, 'return "DIFFERENT"')
+      expect(redis.script(:exists, [sha1, sha2, 'invalidsha'])).to eq([true, true, false])
+    end
+
+    it 'supports evalsha' do
+      sha = redis.script(:load, 'return { KEYS[1], ARGV[1] }')
+      expect(redis.evalsha(sha, ['key1', 'key2'], ['arg1', 'arg2'])).to eq(['key1', 'arg1'])
+    end
+
+    context 'eval arguments' do
+      it 'passes keys as KEYS table' do
+        result = redis.eval('return KEYS[1]', keys: ['first_key', 'second_key'])
+        expect(result).to eq('first_key')
+
+        result = redis.eval('return KEYS[2]', ['first_key', 'second_key'])
+        expect(result).to eq('second_key')
+      end
+
+      it 'passes argv as ARGV table' do
+        result = redis.eval('return ARGV[1]', argv: ['first', 'second'])
+        expect(result).to eq('first')
+
+        result = redis.eval('return ARGV[2]', [], ['first', 'second'])
+        expect(result).to eq('second')
+      end
+
+      it 'should convert keys and argv to lists of strings' do
+        result = redis.eval('return ARGV[2]', argv: [nil, 2.4])
+        expect(result).to eq('2.4')
+
+        result = redis.eval('return KEYS[1]', keys: [:stuff])
+        expect(result).to eq('stuff')
+      end
+    end
+
+    context 'marshalling lua args to redis.call' do
+      it 'should convert lua numbers to strings' do
+        redis.eval(%q| redis.call('set', 'foo', 1.5) |)
+        expect(redis.get('foo')).to eq('1.5')
+      end
+
+      it 'should raise an error if args are not strings or numbers' do
+        lua_script = %q|
+          redis.call('set', 'foo', {'a', 'b', 'c'})
+        |.strip
+        expect { redis.eval(lua_script) }.to raise_error(MockRedisLuaExtension::InvalidCommand) do |ex|
+          expect(ex.message).to match('caused by MockRedisLuaExtension::InvalidDataType')
+        end
+      end
+
+      context 'hash options' do
+        before do
+          redis.zadd('foo', 1, 'washington')
+          redis.zadd('foo', 2, 'jefferson')
+          redis.zadd('foo', 3, 'adams')
+          redis.zadd('foo', 4, 'madison')
+        end
+
+        it 'should convert limits into a hash option' do
+          lua_script = %q|
+           return redis.call('ZRANGEBYSCORE', 'foo', 2, 4, 'LIMIT', 0, 2)
+          |.strip
+          expect(redis.eval(lua_script)).to eq(['jefferson', 'adams'])
+        end
+
+        it 'should convert withscores into a hash option' do
+          lua_script = %q|
+           return redis.call('ZRANGEBYSCORE', 'foo', 2, 3, 'WITHSCORES')
+          |.strip
+          expected_result = ['jefferson', 2.0, 'adams', 3.0]
+          expect(redis.eval(lua_script)).to eq(expected_result)
+        end
+
+        it 'should support both hash options' do
+          lua_script = %q|
+           return redis.call('ZRANGEBYSCORE', 'foo', 2, 4, 'WITHSCORES', 'LIMIT', 1, 2)
+          |.strip
+          expected_result = ['adams', 3.0, 'madison', 4.0]
+          expect(redis.eval(lua_script)).to eq(expected_result)
+        end
+      end
+    end
+
+    context 'marshalling lua return values to ruby' do
+      it 'should convert true to 1' do
+        expect(redis.eval(%q| return true |)).to eq(1)
+      end
+
+      it 'should convert false to nil' do
+        expect(redis.eval(%q| return false |)).to eq(nil)
+      end
+
+      it 'should convert numbers to integers' do
+        expect(redis.eval(%q| return 2.3 |)).to eq(2)
+      end
+
+      it 'should leave strings as is' do
+        expect(redis.eval(%q| return 'a simple string'|)).to eq('a simple string')
+      end
+
+      it 'should convert tables to arrays (ignoring keys)' do
+        expect(redis.eval(%q| return {foo='bar', 'a', 'b', 'c'} |)).to eq(['a', 'b', 'c'])
+      end
+
+      it 'should return redis success responses as "OK"' do
+        lua_script = %q|
+          return redis.call('set', 'foo', 'bar')
+        |.strip
+        expect(redis.eval(lua_script)).to eq('OK')
+      end
+
+      it 'should correctly marshall nested tables' do
+        expect(redis.eval(%q| return {foo='bar', 'a', 1.4, {'b', 2.7}} |)).to eq(['a', 1, ['b', 2]])
+      end
+    end
+
+    context 'cjson implementation' do
+      it 'should decode json strings' do
+        lua_script = %q|
+         local result = cjson.decode('{"foo":"bar","baz":4,"nil_value":null}')
+         return { result.foo, result.baz, result.nil_value }
+        |.strip
+        expect(redis.eval(lua_script)).to eq(['bar', 4])
+      end
+
+      it 'should encode hash-style tables' do
+        lua_script = %q|
+          return cjson.encode({ foo='bar', baz=4, null_value=nil })
+        |.strip
+        expect(redis.eval(lua_script)).to eq('{"baz":4.0,"foo":"bar"}')
+      end
+
+      it 'should encode array-style tables' do
+        lua_script = %q|
+          return cjson.encode({ 'bar', 4, nil })
+        |.strip
+        expect(redis.eval(lua_script)).to eq('["bar",4.0]')
+      end
+
+      it 'should encode strings' do
+        lua_script = %q|
+          return cjson.encode('in_service')
+        |.strip
+        expect(redis.eval(lua_script)).to eq('"in_service"')
+      end
+
+      it 'should encode nil' do
+        lua_script = %q|
+          return cjson.encode(nil)
+        |.strip
+        expect(redis.eval(lua_script)).to eq('null')
+      end
+
+      it 'should encode numbers' do
+        lua_script = %q|
+          return cjson.encode(4)
+        |.strip
+        expect(redis.eval(lua_script)).to eq('4.0')
+      end
+
+      it 'should encode floats' do
+        lua_script = %q|
+          return cjson.encode(4.2)
+        |.strip
+        expect(redis.eval(lua_script)).to eq('4.2')
+      end
+    end
+
+    context 'marshalling redis.call return values to lua' do
+      it 'should convert nil to false' do
+        lua_script = %q|
+          local value = redis.call('get', 'not_defined')
+          if value == nil then
+            redis.call('set', 'value', 'was nil')
+          elseif value == false then
+            redis.call('set', 'value', 'was false')
+          end
+        |.strip
+        redis.eval(lua_script)
+        expect(redis.get('not_defined')).to eq(nil)
+        expect(redis.get('value')).to eq('was false')
+      end
+
+      it 'should marshall arrays into tables' do
+        redis.zadd('myset', 1, 'one')
+        redis.zadd('myset', 2, 'two')
+        redis.zadd('myset', 3, 'three')
+        lua_script = %q|
+           local result = redis.call('zrangebyscore', 'myset', 2, 3)
+           return { result[1], result[2] }
+        |.strip
+        expect(redis.eval(lua_script)).to eq(['two', 'three'])
+      end
+
+      it 'should leave strings and numbers as is' do
+        redis.lpush('string_value', 'value')
+        lua_script = %q|
+          local value = redis.call('lindex', 'string_value', 0)
+          if value == 'value' then
+            redis.call('set', 'string_result', 'was unchanged')
+          else
+            redis.call('set', 'string_result', 'was changed')
+          end
+
+          value = redis.call('llen', 'string_value')
+          if value == 1 then
+            redis.call('set', 'number_result', 'was unchanged')
+          else
+            redis.call('set', 'number_result', 'was changed')
+          end
+        |.strip
+        redis.eval(lua_script)
+        expect(redis.get('string_result')).to eq('was unchanged')
+        expect(redis.get('number_result')).to eq('was unchanged')
+      end
+
+      it 'should return scores as strings' do
+        redis.zadd('myset', 1, 'one')
+        redis.zadd('myset', 2, 'two')
+        redis.zadd('myset', 3, 'three')
+        lua_script = %q|
+          local result = redis.call('zscore', 'myset', 'two')
+          return result
+        |.strip
+
+        expect(redis.eval(lua_script)).to eq('2.0')
+      end
+
+
+      it 'should convert true to 1 and false to 0 when returning from redis' do
+        expect(redis.hset('myhash', 'existing_key', 'first')).to eq(true)
+        expect(redis.hset('myhash', 'existing_key', 'second')).to eq(false)
+        lua_script = %q|
+           local value = redis.call('hset', 'myhash', 'new_key', 'value')
+           if value == 1 then
+             redis.call('set', 'true_value', 'was 1')
+           else
+             redis.call('set', 'true_value', 'was not 1')
+           end
+
+           value = redis.call('hset', 'myhash', 'existing_key', 'third')
+           if value == 0 then
+              redis.call('set', 'false_value', 'was 0')
+            else
+              redis.call('set', 'false_value', 'was not 0')
+            end
+         |.strip
+         redis.eval(lua_script)
+         expect(redis.get('true_value')).to eq('was 1')
+         expect(redis.get('false_value')).to eq('was 0')
+      end
+    end
+
+    context "redis.breakpoint" do
+      it 'calls binding.pry when redis.breakpoint() is called' do
+        expect_any_instance_of(Binding).to receive(:pry)
+        redis.eval("redis.breakpoint()")
+      end
+
+      it 'puts parsed args when redis.debug() is called' do
+        expect_any_instance_of(MockRedis).to receive(:puts).with("hello, hi, 1.0, [5.0, 10.0], {\"monkey\"=>\"banana\", \"number\"=>200.0}, goodbye")
+        lua_script = %q|
+          local var1 = "hi"
+          local var2 = 1.0
+
+          local my_array = {}
+          table.insert(my_array, 5)
+          table.insert(my_array, 10)
+
+          local my_hash = {}
+          my_hash["monkey"] = "banana"
+          my_hash["number"] = 200
+
+          redis.debug("hello", var1, var2, my_array, my_hash, "goodbye")
+        |.strip
+        redis.eval(lua_script)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,88 @@
+require 'pry'
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: mock_redis_lua_extension
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Chad Simmons
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rufus-lua
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- csimmons@invoca.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/mock_redis_lua_extension.rb
+- lib/mock_redis_lua_extension/version.rb
+- mock_redis_lua_extension.gemspec
+- spec/mock_redis_lua_extension_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Invoca/mock_redis_lua_extension
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Extension to mock_redis enabling lua execution via rufus-lua
+test_files:
+- spec/mock_redis_lua_extension_spec.rb
+- spec/spec_helper.rb