ohm 0.1.5 → 1.0.0.alpha1

data/test/{json_test.rb → json.rb}

@@ -33,7 +33,7 @@ test "export a hash with the errors" do
   person = Venue.new
   person.valid?
 
-  assert Hash[:errors => [[:name, :not_present]]] == person.to_hash
+  assert_equal({ errors: { name: [:not_present] }}, person.to_hash)
 end
 
 test "export a hash with the its id" do
@@ -46,8 +46,7 @@ test "export a hash with its id and the errors" do
   person.name = nil
   person.valid?
 
-  expected_hash = { :id => '1', :errors => [[:name, :not_present]] }
-
+  expected_hash = { id: '1', errors: { name: [:not_present] }}
   assert expected_hash == person.to_hash
 end
 
@@ -65,3 +64,11 @@ test "just be the to_hash of a model" do
   assert "1" == json["id"]
   assert "Ruby" == json["language"]
 end
+
+test "export an array of records to json" do
+  Programmer.create(language: "Ruby")
+  Programmer.create(language: "Python")
+
+  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+  assert_equal expected, Programmer.all.to_a.to_json
+end

data/test/lua-save.rb

@@ -0,0 +1,193 @@
+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

@@ -0,0 +1,47 @@
+# 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

data/test/{model_test.rb → model.rb}

@@ -6,7 +6,7 @@ require "ostruct"
 
 class Post < Ohm::Model
   attribute :body
-  list :related, Post
+  set :related, Post
 end
 
 class User < Ohm::Model
@@ -18,12 +18,8 @@ class Person < Ohm::Model
   attribute :name
   index :initial
 
-  def validate
-    assert_present :name
-  end
-
   def initial
-    name[0, 1].upcase
+    name[0, 1].upcase if name
   end
 end
 
@@ -34,7 +30,7 @@ class Event < Ohm::Model
 
   attribute :slug
 
-  def write
+  def save
     self.slug = name.to_s.downcase
     super
   end
@@ -55,6 +51,48 @@ class Meetup < Ohm::Model
   end
 end
 
+test "counters are cleaned up during deletion" do
+  e = Event.create(name: "Foo")
+  e.incr :votes, 10
+
+  assert_equal 10, e.votes
+
+  e.delete
+  assert ! e.key[:counters].exists
+end
+
+test "return the unsaved object if validation fails" do
+  assert Person.create(:name => nil).kind_of?(Person)
+end
+
+test "return false if the validation fails" do
+  event = Meetup.create(:name => "Ruby Tuesday")
+  assert !event.update(:name => nil)
+end
+
+test "get" do
+  m = Meetup.create(name: "Foo")
+  m.name = "Bar"
+
+  assert_equal "Foo", m.get(:name)
+  assert_equal "Foo", m.name
+end
+
+test "set" do
+  m = Meetup.create(name: "Foo")
+
+  m.set :name, "Bar"
+  assert_equal "Bar", m.name
+
+  m = Meetup[m.id]
+  assert_equal "Bar", m.name
+
+  # Deletes when value is nil.
+  m.set :name, nil
+  m = Meetup[m.id]
+  assert ! m.key.hexists(:name)
+end
+
 test "assign attributes from the hash" do
   event = Event.new(:name => "Ruby Tuesday")
   assert event.name == "Ruby Tuesday"
@@ -68,21 +106,12 @@ test "assign an ID and save the object" do
   assert "2" == event2.id
 end
 
-test "return the unsaved object if validation fails" do
-  assert Person.create(:name => nil).kind_of?(Person)
-end
-
 test "updates attributes" do
   event = Meetup.create(:name => "Ruby Tuesday")
   event.update(:name => "Ruby Meetup")
   assert "Ruby Meetup" == event.name
 end
 
-test "return false if the validation fails" do
-  event = Meetup.create(:name => "Ruby Tuesday")
-  assert !event.update(:name => nil)
-end
-
 test "save the attributes in UTF8" do
  event = Meetup.create(:name => "32° Kisei-sen")
  assert "32° Kisei-sen" == Meetup[event.id].name
@@ -92,7 +121,7 @@ test "delete the attribute if set to nil" do
   event = Meetup.create(:name => "Ruby Tuesday", :location => "Los Angeles")
   assert "Los Angeles" == Meetup[event.id].location
   assert event.update(:location => nil)
-  assert nil == Meetup[event.id].location
+  assert_equal nil, Meetup[event.id].location
 end
 
 test "delete the attribute if set to an empty string" do
@@ -122,16 +151,6 @@ test "not raise if a counter is redefined" do
   end
 end
 
-test "not raise if a list is redefined" do
-  class RedefinedModel < Ohm::Model
-    list :todo, lambda { }
-
-    silence_warnings do
-      list :todo, lambda { }
-    end
-  end
-end
-
 test "not raise if a set is redefined" do
   class RedefinedModel < Ohm::Model
     set :friends, lambda { }
@@ -144,7 +163,7 @@ end
 
 test "not raise if a collection is redefined" do
   class RedefinedModel < Ohm::Model
-    list :toys, lambda { }
+    set :toys, lambda { }
 
     silence_warnings do
       set :toys, lambda { }
@@ -225,10 +244,10 @@ end
 
 test "assign a new id to the event" do
   event1 = Event.new
-  event1.create
+  event1.save
 
   event2 = Event.new
-  event2.create
+  event2.save
 
   assert !event1.new?
   assert !event2.new?
@@ -246,7 +265,7 @@ end
 test "save it only if it was previously created" do
   event = Event.new
   event.name = "Lorem ipsum"
-  event.create
+  event.save
 
   event.name = "Lorem"
   event.save
@@ -254,7 +273,7 @@ test "save it only if it was previously created" do
   assert "Lorem" == Event[event.id].name
 end
 
-test "allow to hook into write" do
+test "allow to hook into save" do
   event = Event.create(:name => "Foo")
 
   assert "foo" == event.slug
@@ -266,7 +285,7 @@ test "save counters" do
   event.incr(:votes)
   event.save
 
-  assert 1 == Event[event.id].votes
+  assert_equal 1, Event[event.id].votes
 end
 
 # Delete
@@ -274,13 +293,13 @@ test "delete an existing model" do
   class ModelToBeDeleted < Ohm::Model
     attribute :name
     set :foos, Post
-    list :bars, Post
+    set :bars, Post
   end
 
   @model = ModelToBeDeleted.create(:name => "Lorem")
 
-  @model.foos << Post.create
-  @model.bars << Post.create
+  @model.foos.add(Post.create)
+  @model.bars.add(Post.create)
 
   id = @model.id
 
@@ -303,14 +322,13 @@ test "be no leftover keys" do
     index :name
   end
 
-  assert [] == Ohm.redis.keys("*")
+  assert_equal [], Ohm.redis.keys("*")
 
   Foo.create(:name => "Bar")
-
-  assert ["Foo:1:_indices", "Foo:1", "Foo:all", "Foo:id", "Foo:name:QmFy"].sort == Ohm.redis.keys("*").sort
+  expected = %w[Foo:1 Foo:all Foo:id Foo:indices:name:Bar]
+  assert expected.sort == Ohm.redis.keys("*").sort
 
   Foo[1].delete
-
   assert ["Foo:id"] == Ohm.redis.keys("*")
 end
 
@@ -318,14 +336,13 @@ end
 test "find all" do
   event1 = Event.new
   event1.name = "Ruby Meetup"
-  event1.create
+  event1.save
 
   event2 = Event.new
   event2.name = "Ruby Tuesday"
-  event2.create
+  event2.save
 
   all = Event.all
-
   assert all.detect {|e| e.name == "Ruby Meetup" }
   assert all.detect {|e| e.name == "Ruby Tuesday" }
 end
@@ -337,7 +354,8 @@ test "sort all" do
   Person.create :name => "B"
   Person.create :name => "A"
 
-  assert %w[A B C D] == Person.all.sort_by(:name, :order => "ALPHA").map { |person| person.name }
+  names = Person.all.sort_by(:name, :order => "ALPHA").map { |p| p.name }
+  assert %w[A B C D] == names
 end
 
 test "return an empty array if there are no elements to sort" do
@@ -360,60 +378,58 @@ test "return attribute values when the get parameter is specified" do
   Person.create :name => "B"
   Person.create :name => "A"
 
-  assert "A" == Person.all.sort_by(:name, :get => :name, :order => "ALPHA").first
+  res = Person.all.sort_by(:name, :get => :name, :order => "ALPHA")
+
+  assert_equal ["A", "B"], res
 end
 
 test "work on lists" do
-  @post = Post.create :body => "Hello world!"
-  @post.related << Post.create(:body => "C")
-  @post.related << Post.create(:body => "B")
-  @post.related << Post.create(:body => "A")
+  post = Post.create :body => "Hello world!"
+  post.related.key.rpush(Post.create(:body => "C").id)
+  post.related.key.rpush(Post.create(:body => "B").id)
+  post.related.key.rpush(Post.create(:body => "A").id)
 
-  assert ["A", "B", "C"] == @post.related.sort_by(:body, :order => "ALPHA ASC").map { |model| model.body }
+  res = post.related.sort_by(:body, order: "ALPHA ASC").map { |r| r.body }
+  assert_equal ["A", "B", "C"], res
 end
 
 # Loading attributes
 setup do
   event = Event.new
   event.name = "Ruby Tuesday"
-  @id = event.create.id
+  event.save.id
 end
 
-def monitor
-  log = []
+test "load attributes as a strings" do
+  event = Event.create(:name => 1)
 
-  monitor = Thread.new do
-    Redis.connect.monitor do |line|
-      break if line =~ /ping/
-      log << line
-    end
-  end
+  assert "1" == Event[event.id].name
+end
 
-  sleep 0.01
+# Enumerable indices
+class Entry < Ohm::Model
+  attribute :tags
+  index :tag
 
-  log.clear.tap do
-    yield
-    Ohm.redis.ping
-    monitor.join
+  def tag
+    tags.split(/\s+/)
   end
 end
 
-test "load attributes lazily" do
-  event = Event[@id]
-
-  log = monitor { event.name }
-
-  assert !log.empty?
-
-  log = monitor { event.name }
-
-  assert log.empty?
+setup do
+  Entry.create(tags: "foo bar baz")
 end
 
-test "load attributes as a strings" do
-  event = Event.create(:name => 1)
+test "finding by one entry in the enumerable" do |entry|
+  assert Entry.find(tag: "foo").include?(entry)
+  assert Entry.find(tag: "bar").include?(entry)
+  assert Entry.find(tag: "baz").include?(entry)
+end
 
-  assert "1" == Event[event.id].name
+test "finding by multiple entries in the enumerable" do |entry|
+  assert Entry.find(tag: ["foo", "bar"]).include?(entry)
+  assert Entry.find(tag: ["bar", "baz"]).include?(entry)
+  assert Entry.find(tag: ["baz", "oof"]).empty?
 end
 
 # Attributes of type Set
@@ -426,314 +442,84 @@ setup do
   @event.name = "Ruby Tuesday"
 end
 
+test "filter elements" do
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
+
+  assert [@person1] == @event.attendees.find(:initial => "A").to_a
+  assert [@person2] == @event.attendees.find(:initial => "B").to_a
+  assert [] == @event.attendees.find(:initial => "Z").to_a
+end
+
 test "not be available if the model is new" do
-  assert_raise Ohm::Model::MissingID do
-    @event.attendees << Person.new
+  assert_raise Ohm::MissingID do
+    @event.attendees
   end
 end
 
 test "remove an element if sent delete" do
-  @event.create
-  @event.attendees << @person1
-  @event.attendees << @person2
-  @event.attendees << @person3
-  assert ["1", "2", "3"] == @event.attendees.key.sort
-  @event.attendees.delete(@person2)
-  assert ["1", "3"] == Event[@event.id].attendees.key.sort
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
+  @event.attendees.add(@person3)
+
+  assert_equal ["1", "2", "3"], @event.attendees.key.sort
+
+  @event.attendees.key.srem(@person2.id)
+  assert_equal ["1", "3"], Event[@event.id].attendees.key.sort
 end
 
 test "return true if the set includes some member" do
-  @event.create
-  @event.attendees << @person1
-  @event.attendees << @person2
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
   assert @event.attendees.include?(@person2)
   assert !@event.attendees.include?(@person3)
 end
 
 test "return instances of the passed model" do
-  @event.create
-  @event.attendees << @person1
+  @event.save
+  @event.attendees.add(@person1)
 
-  assert [@person1] == @event.attendees.all
+  assert [@person1] == @event.attendees.to_a
   assert @person1 == @event.attendees[@person1.id]
 end
 
 test "return the size of the set" do
-  @event.create
-  @event.attendees << @person1
-  @event.attendees << @person2
-  @event.attendees << @person3
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
+  @event.attendees.add(@person3)
   assert 3 == @event.attendees.size
 end
 
 test "empty the set" do
-  @event.create
-  @event.attendees << @person1
-
-  @event.attendees.clear
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.key.del
 
   assert @event.attendees.empty?
 end
 
 test "replace the values in the set" do
-  @event.create
-  @event.attendees << @person1
-
-  assert [@person1] == @event.attendees.all
-
-  @event.attendees.replace([@person2, @person3])
-
-  assert [@person2, @person3] == @event.attendees.all.sort_by(&:id)
-end
-
-test "filter elements" do
-  @event.create
+  @event.save
   @event.attendees.add(@person1)
-  @event.attendees.add(@person2)
 
-  assert [@person1] == @event.attendees.find(:initial => "A").all
-  assert [@person2] == @event.attendees.find(:initial => "B").all
-  assert [] == @event.attendees.find(:initial => "Z").all
-end
-
-# Attributes of type List
-setup do
-  @post = Post.new
-  @post.body = "Hello world!"
-  @post.create
-end
-
-test "return an array" do
-  assert @post.related.all.kind_of?(Array)
-end
+  assert [@person1] == @event.attendees.to_a
 
-test "append elements with push" do
-  @post.related.push Post.create
-  @post.related << Post.create
-
-  assert ["2", "3"] == @post.related.all.map { |model| model.id }
-end
-
-test "keep the inserting order" do
-  @post.related << Post.create
-  @post.related << Post.create
-  @post.related << Post.create
-  assert ["2", "3", "4"] == @post.related.all.map { |model| model.id }
-end
-
-test "keep the inserting order after saving" do
-  @post.related << Post.create
-  @post.related << Post.create
-  @post.related << Post.create
-  @post.save
-  assert ["2", "3", "4"] == Post[@post.id].related.map { |model| model.id }
-end
-
-test "allow slicing the list" do
-  post1 = Post.create
-  post2 = Post.create
-  post3 = Post.create
-
-  @post.related << post1
-  @post.related << post2
-  @post.related << post3
-
-  assert post1 == @post.related[0]
-  assert post2 == @post.related[1]
-  assert post3 == @post.related[-1]
-
-  assert nil == @post.related[3]
-
-  assert [post2, post3] == @post.related[1, 2]
-  assert [post2, post3] == @post.related[1, -1]
-
-  assert [] == @post.related[4, 5]
-
-  assert [post2, post3] == @post.related[1..2]
-  assert [post2, post3] == @post.related[1..5]
-
-  assert [] == @post.related[4..5]
-end
-
-test "respond to each" do
-  @post.related << Post.create
-  @post.related << Post.create
-  @post.related << Post.create
-
-  i = 2
-  @post.related.each do |c|
-    assert i == c.id.to_i
-    i += 1
-  end
-end
-
-test "return the size of the list" do
-  @post.related << Post.create
-  @post.related << Post.create
-  @post.related << Post.create
-  assert 3 == @post.related.size
-end
-
-test "return the last element with pop" do
-  @post.related << Post.create
-  @post.related << Post.create
-  assert "3" == @post.related.pop.id
-  assert "2" == @post.related.pop.id
-  assert @post.related.empty?
-end
-
-test "return the first element with shift" do
-  @post.related << Post.create
-  @post.related << Post.create
-  assert "2" == @post.related.shift.id
-  assert "3" == @post.related.shift.id
-  assert @post.related.empty?
-end
-
-test "push to the head of the list with unshift" do
-  @post.related.unshift Post.create
-  @post.related.unshift Post.create
-  assert "2" == @post.related.pop.id
-  assert "3" == @post.related.pop.id
-  assert @post.related.empty?
-end
-
-test "empty the list" do
-  @post.related.unshift Post.create
-  @post.related.clear
-
-  assert @post.related.empty?
-end
-
-test "replace the values in the list" do
-  @post.related.replace([Post.create, Post.create])
-
-  assert ["2", "3"] == @post.related.map { |model| model.id }
-end
-
-test "add models" do
-  @post.related.add(Post.create(:body => "Hello"))
-  assert ["2"] == @post.related.map { |model| model.id }
-end
-
-test "find elements in the list" do
-  another_post = Post.create
-
-  @post.related.add(another_post)
-
-  assert  @post.related.include?(another_post)
-  assert !@post.related.include?(Post.create)
-end
-
-test "unshift models" do
-  @post.related.unshift(Post.create(:body => "Hello"))
-  @post.related.unshift(Post.create(:body => "Goodbye"))
-
-  assert ["3", "2"] == @post.related.map { |model| model.id }
-
-  assert "3" == @post.related.shift.id
-
-  assert "2" == @post.related.pop.id
-
-  assert @post.related.pop.nil?
-end
-
-# Applying arbitrary transformations
-require "date"
-
-class MyActiveRecordModel
-  def self.find(id)
-    return new if id.to_i == 1
-  end
-
-  def id
-    1
-  end
-
-  def ==(other)
-    id == other.id
-  end
-end
-
-class ::Calendar < Ohm::Model
-  list :holidays, lambda { |v| Date.parse(v) }
-  list :subscribers, lambda { |id| MyActiveRecordModel.find(id) }
-  list :appointments, Appointment
-
-  set :events, lambda { |id| MyActiveRecordModel.find(id) }
-end
-
-class ::Appointment < Ohm::Model
-  attribute :text
-  reference :subscriber, lambda { |id| MyActiveRecordModel.find(id) }
-end
-
-setup do
-  @calendar = Calendar.create
-
-  @calendar.holidays.key.rpush "2009-05-25"
-  @calendar.holidays.key.rpush "2009-07-09"
-
-  @calendar.subscribers << MyActiveRecordModel.find(1)
-
-  @calendar.events << MyActiveRecordModel.find(1)
-end
-
-test "apply a transformation" do
-  assert [Date.new(2009, 5, 25), Date.new(2009, 7, 9)] == @calendar.holidays.all
-
-  assert [1] == @calendar.subscribers.all.map { |model| model.id }
-  assert [MyActiveRecordModel.find(1)] == @calendar.subscribers.all
-end
-
-test "doing an each on lists" do
-  arr = []
-  @calendar.subscribers.each do |sub|
-    arr << sub
-  end
-
-  assert [MyActiveRecordModel.find(1)] == arr
-end
-
-test "doing an each on sets" do
-  arr = []
-  @calendar.events.each do |sub|
-    arr << sub
-  end
-
-  assert [MyActiveRecordModel.find(1)] == arr
-end
-
-test "allow lambdas in references" do
-  appointment = Appointment.create(:subscriber => MyActiveRecordModel.find(1))
-  assert MyActiveRecordModel.find(1) == appointment.subscriber
-end
-
-test "work with models too" do
-  @calendar.appointments.add(Appointment.create(:text => "Meet with Bertrand"))
-
-  assert [Appointment[1]] == Calendar[1].appointments.sort
-end
-
-# Sorting lists and sets
-setup do
-  @post = Post.create(:body => "Lorem")
-  @post.related << Post.create
-  @post.related << Post.create
-  @post.related << Post.create
-end
+  @event.attendees.replace([@person2, @person3])
 
-test "sort values" do
-  assert %w{2 3 4} == @post.related.sort.map { |model| model.id }
+  assert [@person2, @person3] == @event.attendees.to_a.sort_by(&:id)
 end
 
 # Sorting lists and sets by model attributes
 setup do
   @event = Event.create(:name => "Ruby Tuesday")
-  @event.attendees << Person.create(:name => "D")
-  @event.attendees << Person.create(:name => "C")
-  @event.attendees << Person.create(:name => "B")
-  @event.attendees << Person.create(:name => "A")
+  @event.attendees.add(Person.create(:name => "D"))
+  @event.attendees.add(Person.create(:name => "C"))
+  @event.attendees.add(Person.create(:name => "B"))
+  @event.attendees.add(Person.create(:name => "A"))
 end
 
 test "sort the model instances by the values provided" do
@@ -742,39 +528,49 @@ test "sort the model instances by the values provided" do
 end
 
 test "accept a number in the limit parameter" do
-  people = @event.attendees.sort_by(:name, :limit => 2, :order => "ALPHA")
+  people = @event.attendees.sort_by(:name, limit: [0, 2], order: "ALPHA")
   assert %w[A B] == people.map { |person| person.name }
 end
 
 test "use the start parameter as an offset if the limit is provided" do
-  people = @event.attendees.sort_by(:name, :limit => 2, :start => 1, :order => "ALPHA")
+  people = @event.attendees.sort_by(:name, limit: [1, 2], order: "ALPHA")
   assert %w[B C] == people.map { |person| person.name }
 end
 
 # Collections initialized with a Model parameter
 setup do
   @user = User.create(:email => "albert@example.com")
-  @user.posts.add Post.create(:body => "D")
-  @user.posts.add Post.create(:body => "C")
-  @user.posts.add Post.create(:body => "B")
-  @user.posts.add Post.create(:body => "A")
+  @user.posts.add(Post.create(:body => "D"))
+  @user.posts.add(Post.create(:body => "C"))
+  @user.posts.add(Post.create(:body => "B"))
+  @user.posts.add(Post.create(:body => "A"))
 end
 
 test "return instances of the passed model" do
   assert Post == @user.posts.first.class
 end
 
+test "remove an object from the set" do
+  post = @user.posts.first
+  assert @user.posts.include?(post)
+
+  @user.posts.key.srem(post.id)
+  assert !@user.posts.include?(post)
+end
+
+test "remove an object id from the set" do
+  post = @user.posts.first
+  assert @user.posts.include?(post)
+
+  @user.posts.key.srem(post.id)
+  assert !@user.posts.include?(post)
+end
+
 # Counters
 setup do
   @event = Event.create(:name => "Ruby Tuesday")
 end
 
-test "raise ArgumentError if the attribute is not a counter" do
-  assert_raise ArgumentError do
-    @event.incr(:name)
-  end
-end
-
 test "be zero if not initialized" do
   assert 0 == @event.votes
 end
@@ -824,7 +620,7 @@ class ::Bar < Ohm::Model
   attribute :name
   counter :visits
   set :friends, self
-  list :comments, self
+  set :comments, self
 
   def foo
     bar.foo
@@ -839,56 +635,6 @@ class ::Bar < Ohm::Model
   end
 end
 
-test "provide a meaningful inspect" do
-  bar = Bar.new
-
-  assert "#<Bar:? name=nil friends=nil comments=nil visits=0>" == bar.inspect
-
-  bar.update(:name => "Albert")
-  bar.friends << Bar.create
-  bar.comments << Bar.create
-  bar.incr(:visits)
-
-  assert %Q{#<Bar:#{bar.id} name="Albert" friends=#<Set (Bar): ["2"]> comments=#<List (Bar): ["3"]> visits=1>} == Bar[bar.id].inspect
-end
-
-def assert_wrapper_exception(&block)
-  begin
-    block.call
-  rescue NoMethodError => exception_raised
-  end
-
-  assert exception_raised.message =~
-  /You tried to call SomeMissingConstant#\w+, but SomeMissingConstant is not defined on #{__FILE__}:\d+:in `bar'/
-end
-
-test "inform about a miscatch by Wrapper when calling class methods" do
-  assert_wrapper_exception { Bar.new.baz }
-end
-
-test "inform about a miscatch by Wrapper when calling instance methods" do
-  assert_wrapper_exception { Bar.new.foo }
-end
-
-# Overwriting write
-class ::Baz < Ohm::Model
-  attribute :name
-
-  def write
-    self.name = "Foobar"
-    super
-  end
-end
-
-test "work properly" do
-  baz = Baz.new
-  baz.name = "Foo"
-  baz.save
-  baz.name = "Foo"
-  baz.save
-  assert "Foobar" == Baz[baz.id].name
-end
-
 # Models connected to different databases
 class ::Car < Ohm::Model
   attribute :name
@@ -924,11 +670,10 @@ end
 
 test "allow changing the database" do
   Car.create(:name => "Twingo")
+  assert_equal ["1"], Car.all.key.smembers
 
-  assert ["1"] == Car.all.key.smembers
-
-  Car.connect
-  assert [] == Car.all.key.smembers
+  Car.connect({})
+  assert_equal [], Car.all.key.smembers
 
   Car.connect :db => 15
   assert ["1"] == Car.all.key.smembers
@@ -941,41 +686,182 @@ test "persist attributes to a hash" do
 
   assert "hash" == Ohm.redis.type("Event:1")
 
-  assert [
-    "Event:1", "Event:all", "Event:id"
-  ].sort == Ohm.redis.keys("Event:*").sort
+  expected= %w[Event:1 Event:1:counters Event:all Event:id]
+  assert_equal expected, Ohm.redis.keys("Event:*").sort
 
   assert "Redis Meetup" == Event[1].name
   assert 1 == Event[1].votes
 end
 
-# a Model with individual attribute writing needs
-class Order < Ohm::Model
-  attribute :state
+# namespaced models
+test "be persisted" do
+  SomeNamespace::Foo.create(:name => "foo")
+
+  assert "hash" == Ohm.redis.type("SomeNamespace::Foo:1")
+
+  assert "foo" == SomeNamespace::Foo[1].name
+end
 
-  def authorize!
-    write_remote :state, 'authorized'
+test "typecast attributes" do
+  class Option < Ohm::Model
+    attribute :votes, lambda { |x| x.to_i }
   end
+
+  option = Option.create :votes => 20
+  option.update(votes: option.votes + 1)
+
+  assert_equal 21, option.votes
 end
 
-test "writes locally" do
-  order = Order.create(:state => "pending")
-  order.authorize!
-  assert 'authorized' == order.state
+test "poster-example for overriding writers" do
+  silence_warnings do
+    class Advertiser < Ohm::Model
+      attribute :email
+
+      def email=(e)
+        attributes[:email] = e.to_s.downcase.strip
+      end
+    end
+  end
+
+  a = Advertiser.new(email: " FOO@BAR.COM ")
+  assert_equal "foo@bar.com", a.email
 end
 
-test "writes remotely" do
-  order = Order.create(:state => "pending")
-  order.authorize!
-  order = Order[order.id]
-  assert 'authorized' == order.state
+__END__
+
+These are the vestigial tests for future reference
+
+def monitor
+  log = []
+
+  monitor = Thread.new do
+    Redis.connect.monitor do |line|
+      break if line =~ /ping/
+      log << line
+    end
+  end
+
+  sleep 0.01
+
+  log.clear.tap do
+    yield
+    Ohm.redis.ping
+    monitor.join
+  end
 end
 
-# namespaced models
-test "be persisted" do
-  SomeNamespace::Foo.create(:name => "foo")
+test "load attributes lazily" do |id|
+  event = Event[id]
 
-  assert "hash" == Ohm.redis.type("SomeNamespace::Foo:1")
+  log = monitor { event.name }
 
-  assert "foo" == SomeNamespace::Foo[1].name
-end
+  assert !log.empty?
+
+  log = monitor { event.name }
+
+  assert log.empty?
+end
+
+test "allow slicing the list" do
+  post1 = Post.create
+  post2 = Post.create
+  post3 = Post.create
+
+  @post.related << post1
+  @post.related << post2
+  @post.related << post3
+
+  assert post1 == @post.related[0]
+  assert post2 == @post.related[1]
+  assert post3 == @post.related[-1]
+
+  assert nil == @post.related[3]
+
+  assert [post2, post3] == @post.related[1, 2]
+  assert [post2, post3] == @post.related[1, -1]
+
+  assert [] == @post.related[4, 5]
+
+  assert [post2, post3] == @post.related[1..2]
+  assert [post2, post3] == @post.related[1..5]
+
+  assert [] == @post.related[4..5]
+end
+
+# Applying arbitrary transformations
+require "date"
+
+class MyActiveRecordModel
+  def self.find(id)
+    return new if id.to_i == 1
+  end
+
+  def id
+    1
+  end
+
+  def ==(other)
+    id == other.id
+  end
+end
+
+class ::Calendar < Ohm::Model
+  list :holidays, lambda { |v| Date.parse(v) }
+  list :subscribers, lambda { |id| MyActiveRecordModel.find(id) }
+  list :appointments, :Appointment
+
+  set :events, lambda { |id| MyActiveRecordModel.find(id) }
+end
+
+class ::Appointment < Ohm::Model
+  attribute :text
+  reference :subscriber, lambda { |id| MyActiveRecordModel.find(id) }
+end
+
+setup do
+  @calendar = Calendar.create
+
+  @calendar.holidays.key.rpush "2009-05-25"
+  @calendar.holidays.key.rpush "2009-07-09"
+
+  @calendar.subscribers << MyActiveRecordModel.find(1)
+
+  @calendar.events << MyActiveRecordModel.find(1)
+end
+
+test "apply a transformation" do
+  assert [Date.new(2009, 5, 25), Date.new(2009, 7, 9)] == @calendar.holidays.all
+
+  assert [1] == @calendar.subscribers.all.map { |model| model.id }
+  assert [MyActiveRecordModel.find(1)] == @calendar.subscribers.all
+end
+
+test "doing an each on lists" do
+  arr = []
+  @calendar.subscribers.each do |sub|
+    arr << sub
+  end
+
+  assert [MyActiveRecordModel.find(1)] == arr
+end
+
+test "doing an each on sets" do
+  arr = []
+  @calendar.events.each do |sub|
+    arr << sub
+  end
+
+  assert [MyActiveRecordModel.find(1)] == arr
+end
+
+test "allow lambdas in references" do
+  appointment = Appointment.create(:subscriber => MyActiveRecordModel.find(1))
+  assert MyActiveRecordModel.find(1) == appointment.subscriber
+end
+
+test "work with models too" do
+  @calendar.appointments.add(Appointment.create(:text => "Meet with Bertrand"))
+
+  assert [Appointment[1]] == Calendar[1].appointments.sort
+end