ohm 1.0.2 → 1.1.0.rc1

data/lib/ohm/command.rb

@@ -0,0 +1,47 @@
+module Ohm
+  class Command
+    def self.[](operation, head, *tail)
+      return head if tail.empty?
+
+      new(operation, head, *tail)
+    end
+
+    attr :operation
+    attr :args
+    attr :keys
+
+    def initialize(operation, *args)
+      @operation = operation
+      @args = args
+      @keys = []
+    end
+
+    def call(nest, db)
+      newkey(nest) do |key|
+        db.send(@operation, key, *params(nest, db))
+      end
+    end
+
+    def clean
+      keys.each { |key| key.del }
+      subcommands.each { |cmd| cmd.clean }
+    end
+
+  private
+    def subcommands
+      args.select { |arg| arg.respond_to?(:call) }
+    end
+
+    def params(nest, db)
+      args.map { |arg| arg.respond_to?(:call) ? arg.call(nest, db) : arg }
+    end
+
+    def newkey(nest)
+      key = nest[SecureRandom.hex(32)]
+      keys << key
+
+      yield  key
+      return key
+    end
+  end
+end

data/lib/ohm.rb

@@ -5,6 +5,7 @@ require "redis"
 require "securerandom"
 require "scrivener"
 require "ohm/transaction"
+require "ohm/command"
 
 module Ohm
 
@@ -66,6 +67,16 @@ module Ohm
       else name
       end
     end
+
+    if Redis::VERSION >= "3.0.0"
+      def self.dict(dict)
+        dict
+      end
+    else
+      def self.dict(arr)
+        Hash[*arr]
+      end
+    end
   end
 
   class Connection
@@ -142,7 +153,7 @@ module Ohm
       return res if arr.nil?
 
       arr.each_with_index do |atts, idx|
-        res << model.new(Hash[*atts].update(:id => ids[idx]))
+        res << model.new(Utils.dict(atts).update(:id => ids[idx]))
       end
 
       res
@@ -417,9 +428,9 @@ module Ohm
     #   set.find(:age => 30)
     #
     def find(dict)
-      filters = model.filters(dict).push(key)
-
-      MultiSet.new(namespace, model).append(:sinterstore, filters)
+      MultiSet.new(
+        namespace, model, Command[:sinterstore, key, *model.filters(dict)]
+      )
     end
 
     # Reduce the set using any number of filters.
@@ -433,7 +444,7 @@ module Ohm
     #   User.find(:name => "John").except(:country => "US")
     #
     def except(dict)
-      MultiSet.new(namespace, model).append(:sinterstore, key).except(dict)
+      MultiSet.new(namespace, model, key).except(dict)
     end
 
     # Do a union to the existing set using any number of filters.
@@ -447,7 +458,7 @@ module Ohm
     #   User.find(:name => "John").union(:name => "Jane")
     #
     def union(dict)
-      MultiSet.new(namespace, model).append(:sinterstore, key).union(dict)
+      MultiSet.new(namespace, model, key).union(dict)
     end
 
   private
@@ -529,15 +540,9 @@ module Ohm
   #   User.find(:name => "John", :age => 30).kind_of?(Ohm::MultiSet)
   #   # => true
   #
-  class MultiSet < Struct.new(:namespace, :model)
+  class MultiSet < Struct.new(:namespace, :model, :command)
     include Collection
 
-    def append(operation, list)
-      filters.push([operation, list])
-
-      return self
-    end
-
     # Chain new fiters on an existing set.
     #
     # Example:
@@ -546,9 +551,9 @@ module Ohm
     #   set.find(:status => 'pending')
     #
     def find(dict)
-      filters.push([:sinterstore, model.filters(dict)])
-
-      return self
+      MultiSet.new(
+        namespace, model, Command[:sinterstore, command, intersected(dict)]
+      )
     end
 
     # Reduce the set using any number of filters.
@@ -562,9 +567,9 @@ module Ohm
     #   User.find(:name => "John").except(:country => "US")
     #
     def except(dict)
-      filters.push([:sdiffstore, model.filters(dict)])
-
-      return self
+      MultiSet.new(
+        namespace, model, Command[:sdiffstore, command, intersected(dict)]
+      )
     end
 
     # Do a union to the existing set using any number of filters.
@@ -578,9 +583,9 @@ module Ohm
     #   User.find(:name => "John").union(:name => "Jane")
     #
     def union(dict)
-      filters.push([:sunionstore, model.filters(dict)])
-
-      return self
+      MultiSet.new(
+        namespace, model, Command[:sunionstore, command, intersected(dict)]
+      )
     end
 
   private
@@ -588,70 +593,27 @@ module Ohm
       model.db
     end
 
-    def filters
-      @filters ||= []
-    end
-
-    def temp_keys
-      @temp_keys ||= []
-    end
-
-    def clean_temp_keys
-      db.del(*temp_keys)
-      temp_keys.clear
-    end
-
-    def generate_temp_key
-      key = namespace[:temp][SecureRandom.hex(32)]
-      temp_keys << key
-      key
+    def intersected(dict)
+      Command[:sinterstore, *model.filters(dict)]
     end
 
     def execute
-
-      # Hold the final result key for this MultiSet.
-      main = nil
-
-      filters.each do |operation, list|
-
-        # Operation can be sinterstore, sdiffstore, or sunionstore.
-        # each operation we do, i.e. `.union(...)`, will be considered
-        # one intersected set, hence we need to `sinterstore` all
-        # the filters in a temporary set.
-        temp = generate_temp_key
-        db.sinterstore(temp, *list)
-
-        # If this is the first set, we simply assign the generated
-        # set to main, which could possibly be the return value
-        # for simple filters like one `.find(...)`.
-        if main.nil?
-          main = temp
-        else
-
-          # Append the generated temporary set using the operation.
-          # i.e. if we have (mood=happy & book=1) and we have an
-          # `sunionstore`, we do (mood=happy & book=1) | (mood=sad & book=1)
-          #
-          # Here we dynamically call the stored command, e.g.
-          #
-          #   SUNIONSTORE main main temp
-          #
-          db.send(operation, main, main, temp)
-        end
-      end
+      # namespace[:tmp] is where all the temp keys should be stored in.
+      # db will be where all the commands are executed against.
+      res = command.call(namespace[:tmp], db)
 
       begin
 
         # At this point, we have the final aggregated set, which we yield
         # to the caller. the caller can do all the normal set operations,
         # i.e. SCARD, SMEMBERS, etc.
-        yield main
+        yield res
 
       ensure
 
         # We have to make sure we clean up the temporary keys to avoid
         # memory leaks and the unintended explosion of memory usage.
-        clean_temp_keys
+        command.clean
       end
     end
   end
@@ -768,7 +730,7 @@ module Ohm
     # Note: The use of this should be a last resort for your actual
     # application runtime, or for simply debugging in your console. If
     # you care about performance, you should pipeline your reads. For
-    # more information checkout the implementation of Ohm::Set#fetch.
+    # more information checkout the implementation of Ohm::List#fetch.
     #
     def self.to_proc
       lambda { |id| self[id] }
@@ -840,7 +802,7 @@ module Ohm
       if keys.size == 1
         Ohm::Set.new(keys.first, key, self)
       else
-        Ohm::MultiSet.new(key, self).append(:sinterstore, keys)
+        Ohm::MultiSet.new(key, self, Command.new(:sinterstore, *keys))
       end
     end
 
@@ -1522,44 +1484,4 @@ module Ohm
       end
     end
   end
-
-  class Lua
-    attr :dir
-    attr :redis
-    attr :files
-    attr :scripts
-
-    def initialize(dir, redis)
-      @dir = dir
-      @redis = redis
-      @files = Hash.new { |h, cmd| h[cmd] = read(cmd) }
-      @scripts = {}
-    end
-
-    def run_file(file, options)
-      run(files[file], options)
-    end
-
-    def run(script, options)
-      keys = options[:keys]
-      argv = options[:argv]
-
-      params = keys + argv
-
-      begin
-        redis.evalsha(sha(script), keys.size, *params)
-      rescue RuntimeError
-        redis.eval(script, keys.size, *params)
-      end
-    end
-
-  private
-    def read(file)
-      File.read("%s/%s.lua" % [dir, file])
-    end
-
-    def sha(script)
-      Digest::SHA1.hexdigest(script)
-    end
-  end
 end

data/test/command.rb

@@ -0,0 +1,57 @@
+require_relative "helper"
+
+scope do
+  setup do
+    redis = Redis.connect
+    redis.flushdb
+
+    # require 'logger'
+    # redis.client.logger = Logger.new(STDOUT)
+    nest  = Nest.new("User:tmp", redis)
+
+    [1, 2, 3].each { |i| redis.sadd("A", i) }
+    [1, 4, 5].each { |i| redis.sadd("B", i) }
+
+    [10, 11, 12].each { |i| redis.sadd("C", i) }
+    [11, 12, 13].each { |i| redis.sadd("D", i) }
+    [12, 13, 14].each { |i| redis.sadd("E", i) }
+
+    [10, 11, 12].each { |i| redis.sadd("F", i) }
+    [11, 12, 13].each { |i| redis.sadd("G", i) }
+    [12, 13, 14].each { |i| redis.sadd("H", i) }
+
+    [redis, nest]
+  end
+
+  test "special condition: single argument returns that arg" do
+    assert_equal "A", Ohm::Command[:sinterstore, "A"]
+  end
+
+  test "full stack test"  do |redis, nest|
+    cmd1 = Ohm::Command[:sinterstore, "A", "B"]
+
+    res = cmd1.call(nest, redis)
+    assert_equal ["1"], res.smembers
+
+    cmd1.clean
+    assert ! res.exists
+
+    cmd2 = Ohm::Command[:sinterstore, "C", "D", "E"]
+    cmd3 = Ohm::Command[:sunionstore, cmd1, cmd2]
+
+    res = cmd3.call(nest, redis)
+    assert_equal ["1", "12"], res.smembers
+
+    cmd3.clean
+    assert redis.keys(nest["*"]).empty?
+
+    cmd4 = Ohm::Command[:sinterstore, "F", "G", "H"]
+    cmd5 = Ohm::Command[:sdiffstore, cmd3, cmd4]
+
+    res = cmd5.call(nest, redis)
+    assert_equal ["1"], res.smembers
+
+    cmd5.clean
+    assert redis.keys(nest["*"]).empty?
+  end
+end

data/test/connection.rb

@@ -2,6 +2,10 @@
 
 require File.expand_path("./helper", File.dirname(__FILE__))
 
+unless defined?(Redis::CannotConnectError)
+  Redis::CannotConnectError = Errno::ECONNREFUSED
+end
+
 prepare.clear
 
 test "no rewriting of settings hash when using Ohm.connect" do
@@ -24,7 +28,7 @@ test "connects lazily" do
   begin
     Ohm.redis.get "foo"
   rescue => e
-    assert_equal Errno::ECONNREFUSED, e.class
+    assert_equal Redis::CannotConnectError, e.class
   end
 end
 
@@ -54,7 +58,7 @@ test "supports connecting by URL" do
   begin
     Ohm.redis.get "foo"
   rescue => e
-    assert_equal Errno::ECONNREFUSED, e.class
+    assert_equal Redis::CannotConnectError, e.class
   end
 end
 

data/test/filtering.rb

@@ -59,6 +59,11 @@ test "#except" do |john, jane|
   assert_equal 2, res.size
   assert res.include?(john)
   assert res.include?(jane)
+
+  res = User.all.except(:status => "inactive")
+
+  assert_equal 2, res.size
+  assert res.include?(jane)
 end
 
 test "indices bug related to a nil attribute" do |john, jane|
@@ -154,3 +159,142 @@ scope do
     assert_equal 2, res.size
   end
 end
+
+# test precision of filtering commands
+require "logger"
+require "stringio"
+scope do
+  class Post < Ohm::Model
+    attribute :author
+    index :author
+
+    attribute :mood
+    index :mood
+  end
+
+  setup do
+    io = StringIO.new
+
+    Post.connect(:logger => Logger.new(io))
+
+    Post.create(author: "matz", mood: "happy")
+    Post.create(author: "rich", mood: "mad")
+
+    io
+  end
+
+  def read(io)
+    io.rewind
+    io.read
+  end
+
+  test "SINTERSTORE a b" do |io|
+    Post.find(author: "matz").find(mood: "happy").to_a
+
+    # This is the simple case. We should only do one SINTERSTORE
+    # given two direct keys. Anything more and we're performing badly.
+    expected = "SINTERSTORE Post:tmp:[a-f0-9]{64} " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test "SUNIONSTORE a b" do |io|
+    Post.find(author: "matz").union(mood: "happy").to_a
+
+    # Another simple case where we must only do one operation at maximum.
+    expected = "SUNIONSTORE Post:tmp:[a-f0-9]{64} " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test "SUNIONSTORE c (SINTERSTORE a b)" do |io|
+    Post.find(author: "matz").find(mood: "happy").union(author: "rich").to_a
+
+    # For this case we need an intermediate key. This will
+    # contain the intersection of matz + happy.
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    assert(read(io) =~ Regexp.new(expected))
+
+    # The next operation is simply doing a UNION of the previously
+    # generated intermediate key and the additional single key.
+    expected = "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "%s Post:indices:author:rich" % $1
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test "SUNIONSTORE (SINTERSTORE c d) (SINTERSTORE a b)" do |io|
+    Post.find(author: "matz").find(mood: "happy").
+         union(author: "rich", mood: "sad").to_a
+
+    # Similar to the previous case, we need to do an intermediate
+    # operation.
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    match1 = read(io).match(Regexp.new(expected))
+    assert match1
+
+    # But now, we need to also hold another intermediate key for the
+    # condition of author: rich AND mood: sad.
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:rich Post:indices:mood:sad"
+
+    match2 = read(io).match(Regexp.new(expected))
+    assert match2
+
+    # Now we expect that it does a UNION of those two previous
+    # intermediate keys.
+    expected = sprintf(
+      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
+      match1[1], match2[1]
+    )
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test do |io|
+    Post.create(author: "kent", mood: "sad")
+
+    Post.find(author: "kent", mood: "sad").
+         union(author: "matz", mood: "happy").
+         except(mood: "sad", author: "rich").to_a
+
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:kent Post:indices:mood:sad"
+
+    match1 = read(io).match(Regexp.new(expected))
+    assert match1
+
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    match2 = read(io).match(Regexp.new(expected))
+    assert match2
+
+    expected = sprintf(
+      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
+      match1[1], match2[1]
+    )
+
+    match3 = read(io).match(Regexp.new(expected))
+    assert match3
+
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:mood:sad Post:indices:author:rich"
+
+    match4 = read(io).match(Regexp.new(expected))
+    assert match4
+
+    expected = sprintf(
+      "SDIFFSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
+      match3[1], match4[1]
+    )
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: ohm
 version: !ruby/object:Gem::Version
-  version: 1.0.2
-  prerelease: 
+  version: 1.1.0.rc1
+  prerelease: 6
 platform: ruby
 authors:
 - Michel Martens
@@ -11,24 +11,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-25 00:00:00.000000000 Z
+date: 2012-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: nest
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +88,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/ohm/command.rb
 - lib/ohm/json.rb
 - lib/ohm/transaction.rb
 - lib/ohm.rb
@@ -96,6 +97,7 @@ files:
 - Rakefile
 - test/1.8.6_test.rb
 - test/association.rb
+- test/command.rb
 - test/connection.rb
 - test/core.rb
 - test/counters.rb
@@ -107,8 +109,6 @@ files:
 - test/issue-52.rb
 - test/json.rb
 - test/list.rb
-- test/lua-save.rb
-- test/lua.rb
 - test/model.rb
 - test/pipeline-performance.rb
 - test/transactions.rb
@@ -130,9 +130,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: ohm
 rubygems_version: 1.8.23

data/test/lua-save.rb

@@ -1,193 +0,0 @@
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-def redis
-  Ohm.redis
-end
-
-begin
-  Ohm.redis.script("flush")
-rescue RuntimeError
-  # We're running on Redis < 2.6, so we
-  # skip all the test.
-else
-  setup do
-    Ohm.redis.script("flush")
-
-    redis.sadd("User:uniques", "email")
-    redis.sadd("User:indices", "fname")
-    redis.sadd("User:indices", "lname")
-    redis.hset("User:uniques:email", "foo@bar.com", 1)
-
-    Ohm::Lua.new("./test/lua", redis)
-  end
-
-  test "empty email doesn't choke" do |lua|
-    res = lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", nil])
-
-    assert_equal [200, ["id", "1"]], res
-    assert_equal "1", redis.hget("User:uniques:email", nil)
-  end
-
-  test "empty fname / lname doesn't choke" do |lua|
-    res = lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", nil, "fname", nil, "lname", nil])
-
-    assert_equal [200, ["id", "1"]], res
-    assert redis.sismember("User:indices:fname:", 1)
-    assert redis.sismember("User:indices:lname:", 1)
-  end
-
-  test "returns the unique constraint error" do |lua|
-    res = lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "foo@bar.com"])
-
-    assert_equal [500, ["email", "not_unique"]], res
-  end
-
-  test "persists the unique entry properly" do |lua|
-    lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "bar@baz.com"])
-
-    assert_equal "1", redis.hget("User:uniques:email", "bar@baz.com")
-  end
-
-  test "adds the entry to User:all" do |lua|
-    lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "bar@baz.com"])
-
-    assert_equal 1, redis.scard("User:all")
-  end
-
-
-  test "saves the attributes" do |lua|
-    lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
-
-    assert_equal "bar@baz.com", redis.hget("User:1", "email")
-    assert_equal "John", redis.hget("User:1", "fname")
-    assert_equal "Doe", redis.hget("User:1", "lname")
-  end
-
-  test "indexes fname / lname" do |lua|
-    lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
-
-    assert redis.sismember("User:indices:fname:John", 1)
-    assert redis.sismember("User:indices:lname:Doe", 1)
-  end
-
-  test "unique constraint during update" do |lua|
-    lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
-
-    res = lua.run_file("save",
-      :keys => ["User", "User:1"],
-      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
-
-    assert_equal [200, ["id", "1"]], res
-
-    res = lua.run_file("save",
-      :keys => ["User", "User:1"],
-      :argv => ["email", "foo@bar.com", "fname", "Jane", "lname", "Doe"])
-
-    assert_equal [200, ["id", "1"]], res
-  end
-
-  test "cleanup of existing indices during update" do |lua|
-    lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
-
-    res = lua.run_file("save",
-      :keys => ["User", "User:1"],
-      :argv => ["email", "foo@bar.com", "fname", "Jane", "lname", "Smith"])
-
-    assert ! redis.sismember("User:indices:fname:John", 1)
-    assert ! redis.sismember("User:indices:fname:Doe", 1)
-  end
-
-  test "cleanup of existing uniques during update" do |lua|
-    lua.run_file("save",
-      :keys => ["User"],
-      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
-
-    res = lua.run_file("save",
-      :keys => ["User", "User:1"],
-      :argv => ["email", "foo@bar.com", "fname", "Jane", "lname", "Smith"])
-
-    assert_equal nil, redis.hget("User:uniques:email", "bar@baz.com")
-  end
-end
-
-__END__
-$VERBOSE = false
-
-test "stress test for lua scripting" do |lua|
-  require "benchmark"
-
-  class User < Ohm::Model
-    attribute :email
-    attribute :fname
-    attribute :lname
-
-    index :email
-    index :fname
-    index :lname
-  end
-
-  t = Benchmark.measure do
-    threads = 100.times.map do |i|
-      Thread.new do
-        User.create(:email => "foo#{i}@bar.com",
-                    :fname => "Jane#{i}",
-                    :lname => "Smith#{i}")
-      end
-    end
-
-    threads.each(&:join)
-  end
-
-  puts t
-end
-
-test "stress test for postgres + sequel (as a comparison)" do
-  require "sequel"
-
-  DB = Sequel.connect("postgres://cyx@localhost/postgres")
-  DB[:users].truncate
-  t = Benchmark.measure do
-    threads = 100.times.map do |i|
-      Thread.new do
-        DB[:users].insert(:email => "foo#{i}@bar.com",
-                          :fname => "John#{i}",
-                          :lname => "Doe#{i}")
-      end
-    end
-
-    threads.each(&:join)
-  end
-
-  puts t
-end
-
-## Result for 100 threads:
-#  0.040000   0.010000   0.050000 (  0.061512) - lua script
-#  0.150000   0.180000   0.330000 (  0.259676) - postgres
-#
-## Result for 100 linear executions:
-#
-#  0.010000   0.010000   0.020000 (  0.032064) - lua script
-#  0.010000   0.010000   0.020000 (  0.059540) - postgres
-#
-## It's also important to note that with 1K concurrent threads,
-#  postgres throws a Sequel::PoolTimeout
-end

data/test/lua.rb

@@ -1,47 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-begin
-  Ohm.redis.script("flush")
-rescue RuntimeError
-  # We're running on Redis < 2.6, so we
-  # skip all the test.
-else
-  setup do
-    Ohm::Lua.new("./test/lua", Ohm.redis)
-  end
-
-  test do |lua|
-    lua.redis.set("foo", "baz")
-
-    res = lua.run_file("getset", :keys => ["foo"], :argv => ["bar"])
-    assert_equal ["baz", "bar"], res
-  end
-
-  test do |lua|
-    res = lua.run_file("ohm-save",
-      :keys => ["User"],
-      :argv => ["fname", "John", "lname", "Doe"])
-
-    assert lua.redis.sismember("User:all", 1)
-    assert_equal({ "fname" => "John", "lname" => "Doe" },
-      lua.redis.hgetall("User:1"))
-  end
-
-  test do |lua|
-    lua.redis.sadd("User:indices", "fname")
-    lua.redis.sadd("User:indices", "lname")
-
-    res = lua.run_file("save-with-indices",
-      :keys => ["User:1", "User:all", "User:indices"],
-      :argv => ["fname", "John", "lname", "Doe"])
-
-    assert lua.redis.sismember("User:all", 1)
-
-    assert lua.redis.sismember("User:fname:John", 1)
-    assert lua.redis.sismember("User:lname:Doe", 1)
-    assert lua.redis.sismember("User:1:_indices", "User:fname:John")
-    assert lua.redis.sismember("User:1:_indices", "User:lname:Doe")
-  end
-end