ohm_util 0.1

data/test/helper.rb

@@ -0,0 +1,23 @@
+begin
+  require "ruby-debug"
+rescue LoadError
+end
+
+require "cutest"
+
+def silence_warnings
+  original_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = original_verbose
+end unless defined?(silence_warnings)
+
+$VERBOSE = true
+
+require_relative "../lib/ohm"
+
+Ohm.redis = Redic.new("redis://127.0.0.1:6379")
+
+prepare do
+  Ohm.redis.call("FLUSHALL")
+end

data/test/indices.rb

@@ -0,0 +1,138 @@
+require_relative "helper"
+
+class User < Ohm::Model
+  attribute :email
+  attribute :update
+  attribute :activation_code
+  attribute :sandunga
+  index :email
+  index :email_provider
+  index :working_days
+  index :update
+  index :activation_code
+
+  def working_days
+    @working_days ||= []
+  end
+
+  def email_provider
+    email.split("@").last
+  end
+
+  def before_save
+    self.activation_code ||= "user:#{id}"
+  end
+end
+
+setup do
+  @user1 = User.create(:email => "foo", :activation_code => "bar", :update => "baz")
+  @user2 = User.create(:email => "bar")
+  @user3 = User.create(:email => "baz qux")
+end
+
+test "be able to find by the given attribute" do
+  assert @user1 == User.find(:email => "foo").first
+end
+
+test "raise if the index doesn't exist" do
+  assert_raise Ohm::IndexNotFound do
+    User.find(:address => "foo")
+  end
+end
+
+test "raise an error if the parameter supplied is not a hash" do
+  begin
+    User.find(1)
+  rescue => ex
+  ensure
+    assert ex.kind_of?(ArgumentError)
+    assert ex.message == "You need to supply a hash with filters. If you want to find by ID, use User[id] instead."
+  end
+end
+
+test "avoid intersections with the all collection" do
+  assert_equal "User:indices:email:foo", User.find(:email => "foo").key.to_s
+end
+
+test "allow multiple chained finds" do
+  assert 1 == User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").size
+end
+
+test "return nil if no results are found" do
+  assert User.find(:email => "foobar").empty?
+  assert nil == User.find(:email => "foobar").first
+end
+
+test "update indices when changing attribute values" do
+  @user1.email = "baz"
+  @user1.save
+
+  assert [] == User.find(:email => "foo").to_a
+  assert [@user1] == User.find(:email => "baz").to_a
+end
+
+test "remove from the index after deleting" do
+  @user2.delete
+
+  assert [] == User.find(:email => "bar").to_a
+end
+
+test "work with attributes that contain spaces" do
+  assert [@user3] == User.find(:email => "baz qux").to_a
+end
+
+# Indexing arbitrary attributes
+setup do
+  @user1 = User.create(:email => "foo@gmail.com")
+  @user2 = User.create(:email => "bar@gmail.com")
+  @user3 = User.create(:email => "bazqux@yahoo.com")
+end
+
+test "allow indexing by an arbitrary attribute" do
+  gmail = User.find(:email_provider => "gmail.com").to_a
+  assert [@user1, @user2] == gmail.sort_by { |u| u.id }
+  assert [@user3] == User.find(:email_provider => "yahoo.com").to_a
+end
+
+scope do
+  # Just to give more context around this bug, basically it happens
+  # when you define a virtual unique or index.
+  #
+  # Previously it was unable to cleanup the indices mainly because
+  # it relied on the attributes being set.
+  class Node < Ohm::Model
+    index :available
+    attribute :capacity
+
+    unique :available
+
+    def available
+      capacity.to_i <= 90
+    end
+  end
+
+  test "index bug" do
+    n = Node.create
+    n.update(capacity: 91)
+
+    assert_equal 0, Node.find(available: true).size
+  end
+
+  test "uniques bug" do
+    n = Node.create
+    n.update(capacity: 91)
+
+    assert_equal nil, Node.with(:available, true)
+  end
+  
+  test "float to string" do
+    u1 = User.create(:email => "foo", :update => 3.0)
+    u2 = User.create(:email => "bar", :update => 3)
+    
+    assert User.find(:update => 3.0).include?(u1)
+    assert User.find(:update => 3).include?(u2)
+    
+    assert !User.find(:update => 3.0).include?(u2)
+    assert !User.find(:update => 3).include?(u1)
+  end
+end

data/test/json.rb

@@ -0,0 +1,62 @@
+require_relative 'helper'
+require_relative "../lib/ohm/json"
+
+class Venue < Ohm::Model
+  attribute :name
+  list :programmers, :Programmer
+end
+
+class Programmer < Ohm::Model
+  attribute :language
+
+  index :language
+
+  def to_hash
+    super.merge(language: language)
+  end
+end
+
+test "exports model.to_hash to json" do
+  assert_equal Hash.new, JSON.parse(Venue.new.to_json)
+
+  venue = Venue.create(name: "foo")
+  json  = JSON.parse(venue.to_json)
+  assert_equal venue.id, json["id"]
+  assert_equal nil, json["name"]
+
+  programmer = Programmer.create(language: "Ruby")
+  json = JSON.parse(programmer.to_json)
+
+  assert_equal programmer.id, json["id"]
+  assert_equal programmer.language, json["language"]
+end
+
+test "exports a set 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_json
+end
+
+test "exports a multiset to json" do
+  Programmer.create(language: "Ruby")
+  Programmer.create(language: "Python")
+
+  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+  result   = Programmer.find(language: "Ruby").union(language: "Python").to_json
+
+  assert_equal expected, result
+end
+
+test "exports a list to json" do
+  venue = Venue.create(name: "Foo")
+
+  venue.programmers.push(Programmer.create(language: "Ruby"))
+  venue.programmers.push(Programmer.create(language: "Python"))
+
+  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+
+  assert_equal expected, venue.programmers.to_json
+end

data/test/list.rb

@@ -0,0 +1,83 @@
+require_relative "helper"
+
+class Post < Ohm::Model
+  list :comments, :Comment
+end
+
+class Comment < Ohm::Model
+end
+
+setup do
+  post = Post.create
+
+  post.comments.push(c1 = Comment.create)
+  post.comments.push(c2 = Comment.create)
+  post.comments.push(c3 = Comment.create)
+
+  [post, c1, c2, c3]
+end
+
+test "include?" do |p, c1, c2, c3|
+  assert p.comments.include?(c1)
+  assert p.comments.include?(c2)
+  assert p.comments.include?(c3)
+end
+
+test "first / last / size / empty?" do |p, c1, c2, c3|
+  assert_equal 3, p.comments.size
+  assert_equal c1, p.comments.first
+  assert_equal c3, p.comments.last
+  assert ! p.comments.empty?
+end
+
+test "replace" do |p, c1, c2, c3|
+  c4 = Comment.create
+
+  p.comments.replace([c4])
+
+  assert_equal [c4], p.comments.to_a
+end
+
+test "push / unshift" do |p, c1, c2, c3|
+  c4 = Comment.create
+  c5 = Comment.create
+
+  p.comments.unshift(c4)
+  p.comments.push(c5)
+
+  assert_equal c4, p.comments.first
+  assert_equal c5, p.comments.last
+end
+
+test "delete" do |p, c1, c2, c3|
+  p.comments.delete(c1)
+  assert_equal 2, p.comments.size
+  assert ! p.comments.include?(c1)
+
+  p.comments.delete(c2)
+  assert_equal 1, p.comments.size
+  assert ! p.comments.include?(c2)
+
+  p.comments.delete(c3)
+  assert p.comments.empty?
+end
+
+test "deleting main model cleans up the collection" do |p, _, _, _|
+  p.delete
+
+  assert_equal 0, Ohm.redis.call("EXISTS", p.key[:comments])
+end
+
+test "#ids returns an array with the ids" do |post, *comments|
+  assert_equal comments.map(&:id), post.comments.ids
+end
+
+test "range" do |p, c1, c2, c3|
+  assert_equal 3, p.comments.range(0, 100).size
+  assert_equal [c1, c2, c3], p.comments.range(0, 2)
+  assert_equal [c1, c2], p.comments.range(0, 1)
+  assert_equal [c2, c3], p.comments.range(1, 2)
+  assert_equal [c1, c2, c3], p.comments.range(0, -1)
+  assert_equal [c1, c2], p.comments.range(0, -2)
+  assert_equal [c2, c3], p.comments.range(1, -1)
+end

data/test/model.rb

@@ -0,0 +1,819 @@
+require_relative "helper"
+require "ostruct"
+
+class Post < Ohm::Model
+  attribute :body
+  attribute :published
+  set :related, :Post
+end
+
+class User < Ohm::Model
+  attribute :email
+  set :posts, :Post
+end
+
+class Person < Ohm::Model
+  attribute :name
+  counter :logins
+  index :initial
+
+  def initial
+    name[0, 1].upcase if name
+  end
+end
+
+class Event < Ohm::Model
+  attribute :name
+  counter :votes
+  set :attendees, :Person
+
+  attribute :slug
+
+  def save
+    self.slug = name.to_s.downcase
+    super
+  end
+end
+
+module SomeNamespace
+  class Foo < Ohm::Model
+    attribute :name
+  end
+
+  class Bar < Ohm::Model
+    reference :foo, 'SomeNamespace::Foo'
+  end
+end
+
+class Meetup < Ohm::Model
+  attribute :name
+  attribute :location
+end
+
+test "booleans" do
+  post = Post.new(body: true, published: false)
+
+  post.save
+
+  assert_equal true, post.body
+  assert_equal false, post.published
+
+  post = Post[post.id]
+
+  assert_equal "true", post.body
+  assert_equal nil, post.published
+end
+
+test "empty model is ok" do
+  class Foo < Ohm::Model
+  end
+
+  Foo.create
+end
+
+test "counters are cleaned up during deletion" do
+  e = Event.create(:name => "Foo")
+  e.increment :votes, 10
+
+  assert_equal 10, e.votes
+
+  e.delete
+  assert_equal 0, Event.redis.call("EXISTS", e.key[:counters])
+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_equal 0, Meetup.redis.call("HEXISTS", m.key, :name)
+end
+
+test "assign attributes from the hash" do
+  event = Event.new(:name => "Ruby Tuesday")
+  assert event.name == "Ruby Tuesday"
+end
+
+test "assign an ID and save the object" do
+  event1 = Event.create(name: "Ruby Tuesday")
+  event2 = Event.create(name: "Ruby Meetup")
+
+  assert_equal "1", event1.id
+  assert_equal "2", event2.id
+end
+
+test "updates attributes" do
+  event = Meetup.create(:name => "Ruby Tuesday")
+  event.update(:name => "Ruby Meetup")
+  assert "Ruby Meetup" == event.name
+end
+
+test "reload attributes" do
+  event1 = Meetup.create(:name => "Foo", :location => "Bar")
+  event2 = Meetup[event1.id]
+
+  assert_equal "Foo", event1.name
+  assert_equal "Bar", event1.location
+
+  assert_equal "Foo", event2.name
+  assert_equal "Bar", event2.location
+
+  event1.update(:name => nil)
+  event2.load!
+
+  assert_equal nil, event1.name
+  assert_equal "Bar", event1.location
+
+  assert_equal nil, event2.name
+  assert_equal "Bar", event2.location
+end
+
+test "save the attributes in UTF8" do
+ event = Meetup.create(:name => "32° Kisei-sen")
+ assert "32° Kisei-sen" == Meetup[event.id].name
+end
+
+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_equal nil, Meetup[event.id].location
+end
+
+test "not raise if an attribute is redefined" do
+  class RedefinedModel < Ohm::Model
+    attribute :name
+
+    silence_warnings do
+      attribute :name
+    end
+  end
+end
+
+test "not raise if a counter is redefined" do
+  class RedefinedModel < Ohm::Model
+    counter :age
+
+    silence_warnings do
+      counter :age
+    end
+  end
+end
+
+test "not raise if a set is redefined" do
+  class RedefinedModel < Ohm::Model
+    set :friends, lambda { }
+
+    silence_warnings do
+      set :friends, lambda { }
+    end
+  end
+end
+
+test "not raise if a collection is redefined" do
+  class RedefinedModel < Ohm::Model
+    set :toys, lambda { }
+
+    silence_warnings do
+      set :toys, lambda { }
+    end
+  end
+end
+
+test "not raise if a index is redefined" do
+  class RedefinedModel < Ohm::Model
+    attribute :color
+    index :color
+    index :color
+  end
+end
+
+test "allow arbitrary IDs" do
+  Event.create(:id => "abc123", :name => "Concert")
+
+  assert Event.all.size == 1
+  assert Event["abc123"].name == "Concert"
+end
+
+test "forbid assignment of IDs on a new object" do
+  event = Event.new(:name => "Concert")
+
+  assert_raise(NoMethodError) do
+    event.id = "abc123"
+  end
+end
+
+setup do
+  Ohm.redis.call("SADD", "Event:all", 1)
+  Ohm.redis.call("HSET", "Event:1", "name", "Concert")
+end
+
+test "return an instance of Event" do
+  assert Event[1].kind_of?(Event)
+  assert 1 == Event[1].id
+  assert "Concert" == Event[1].name
+end
+
+setup do
+  Ohm.redis.call("SADD", "User:all", 1)
+  Ohm.redis.call("HSET", "User:1", "email", "albert@example.com")
+end
+
+test "return an instance of User" do
+  assert User[1].kind_of?(User)
+  assert 1 == User[1].id
+  assert "albert@example.com" == User[1].email
+end
+
+test "allow to map key to models" do
+  assert [User[1]] == [1].map(&User)
+end
+
+setup do
+  Ohm.redis.call("SADD", "User:all", 1)
+  Ohm.redis.call("SET", "User:1:email", "albert@example.com")
+
+  @user = User[1]
+end
+
+test "change its attributes" do
+  @user.email = "maria@example.com"
+  assert "maria@example.com" == @user.email
+end
+
+test "save the new values" do
+  @user.email = "maria@example.com"
+  @user.save
+
+  @user.email = "maria@example.com"
+  @user.save
+
+  assert "maria@example.com" == User[1].email
+end
+
+test "assign a new id to the event" do
+  event1 = Event.new
+  event1.save
+
+  event2 = Event.new
+  event2.save
+
+  assert !event1.new?
+  assert !event2.new?
+
+  assert_equal "1", event1.id
+  assert_equal "2", event2.id
+end
+
+# Saving a model
+test "create the model if it is new" do
+  event = Event.new(:name => "Foo").save
+  assert "Foo" == Event[event.id].name
+end
+
+test "save it only if it was previously created" do
+  event = Event.new
+  event.name = "Lorem ipsum"
+  event.save
+
+  event.name = "Lorem"
+  event.save
+
+  assert "Lorem" == Event[event.id].name
+end
+
+test "allow to hook into save" do
+  event = Event.create(:name => "Foo")
+
+  assert "foo" == event.slug
+end
+
+test "save counters" do
+  event = Event.create(:name => "Foo")
+
+  event.increment(:votes)
+  event.save
+
+  assert_equal 1, Event[event.id].votes
+end
+
+# Delete
+test "delete an existing model" do
+  class ModelToBeDeleted < Ohm::Model
+    attribute :name
+    set :foos, :Post
+    set :bars, :Post
+  end
+
+  @model = ModelToBeDeleted.create(:name => "Lorem")
+
+  @model.foos.add(Post.create)
+  @model.bars.add(Post.create)
+
+  id = @model.id
+
+  @model.delete
+
+  assert Ohm.redis.call("GET", ModelToBeDeleted.key[id]).nil?
+  assert Ohm.redis.call("GET", ModelToBeDeleted.key[id][:name]).nil?
+  assert Array.new == Ohm.redis.call("SMEMBERS", ModelToBeDeleted.key[id][:foos])
+  assert Array.new == Ohm.redis.call("LRANGE", ModelToBeDeleted.key[id][:bars], 0, -1)
+
+  assert ModelToBeDeleted.all.empty?
+end
+
+setup do
+end
+
+test "no leftover keys" do
+  class ::Foo < Ohm::Model
+    attribute :name
+    index :name
+    track :notes
+  end
+
+  assert_equal [], Ohm.redis.call("KEYS", "*")
+
+  Foo.create(:name => "Bar")
+  expected = %w[Foo:1:_indices Foo:1 Foo:all Foo:id Foo:indices:name:Bar]
+
+  assert_equal expected.sort, Ohm.redis.call("KEYS", "*").sort
+
+  Foo[1].delete
+  assert ["Foo:id"] == Ohm.redis.call("KEYS", "*")
+
+  Foo.create(:name => "Baz")
+
+  Ohm.redis.call("SET", Foo[2].key[:notes], "something")
+
+  expected = %w[Foo:2:_indices Foo:2 Foo:all Foo:id
+    Foo:indices:name:Baz Foo:2:notes]
+
+  assert_equal expected.sort, Ohm.redis.call("KEYS", "*").sort
+
+  Foo[2].delete
+  assert ["Foo:id"] == Ohm.redis.call("KEYS", "*")
+end
+
+# Listing
+test "find all" do
+  event1 = Event.new
+  event1.name = "Ruby Meetup"
+  event1.save
+
+  event2 = Event.new
+  event2.name = "Ruby Tuesday"
+  event2.save
+
+  all = Event.all
+  assert all.detect {|e| e.name == "Ruby Meetup" }
+  assert all.detect {|e| e.name == "Ruby Tuesday" }
+end
+
+# Fetching
+test "fetch ids" do
+  event1 = Event.create(:name => "A")
+  event2 = Event.create(:name => "B")
+
+  assert_equal [event1, event2], Event.fetch([event1.id, event2.id])
+end
+
+# Sorting
+test "sort all" do
+  Person.create :name => "D"
+  Person.create :name => "C"
+  Person.create :name => "B"
+  Person.create :name => "A"
+
+  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
+  assert [] == Person.all.sort_by(:name)
+end
+
+test "return the first element sorted by id when using first" do
+  Person.create :name => "A"
+  Person.create :name => "B"
+  assert "A" == Person.all.first.name
+end
+
+test "return the first element sorted by name if first receives a sorting option" do
+  Person.create :name => "B"
+  Person.create :name => "A"
+  assert "A" == Person.all.first(:by => :name, :order => "ALPHA").name
+end
+
+test "return attribute values when the get parameter is specified" do
+  Person.create :name => "B"
+  Person.create :name => "A"
+
+  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!"
+
+  redis = Post.redis
+
+  redis.call("RPUSH", post.related.key, Post.create(:body => "C").id)
+  redis.call("RPUSH", post.related.key, Post.create(:body => "B").id)
+  redis.call("RPUSH", post.related.key, Post.create(:body => "A").id)
+
+  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"
+  event.save.id
+end
+
+test "load attributes as a strings" do
+  event = Event.create(:name => 1)
+
+  assert "1" == Event[event.id].name
+end
+
+# Enumerable indices
+class Entry < Ohm::Model
+  attribute :tags
+  index :tag
+
+  def tag
+    tags.split(/\s+/)
+  end
+end
+
+setup do
+  Entry.create(:tags => "foo bar baz")
+end
+
+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
+
+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
+setup do
+  @person1 = Person.create(:name => "Albert")
+  @person2 = Person.create(:name => "Bertrand")
+  @person3 = Person.create(:name => "Charles")
+
+  @event = Event.new
+  @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 "delete elements" do
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
+
+  assert_equal 2, @event.attendees.size
+
+  @event.attendees.delete(@person2)
+  assert_equal 1, @event.attendees.size
+end
+
+test "not be available if the model is new" do
+  assert_raise Ohm::MissingID do
+    @event.attendees
+  end
+end
+
+test "remove an element if sent delete" do
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
+  @event.attendees.add(@person3)
+
+  assert_equal ["1", "2", "3"], Event.redis.call("SORT", @event.attendees.key)
+
+  Event.redis.call("SREM", @event.attendees.key, @person2.id)
+  assert_equal ["1", "3"], Event.redis.call("SORT", Event[@event.id].attendees.key)
+end
+
+test "return true if the set includes some member" do
+  @event.save
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
+  assert @event.attendees.include?(@person2)
+
+  @event.attendees.include?(@person3)
+  assert !@event.attendees.include?(@person3)
+end
+
+test "return instances of the passed model" do
+  @event.save
+  @event.attendees.add(@person1)
+
+  assert [@person1] == @event.attendees.to_a
+  assert @person1 == @event.attendees[@person1.id]
+end
+
+test "return the size of the set" do
+  @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.save
+  @event.attendees.add(@person1)
+
+  Event.redis.call("DEL", @event.attendees.key)
+
+  assert @event.attendees.empty?
+end
+
+test "replace the values in the set" do
+  @event.save
+  @event.attendees.add(@person1)
+
+  assert [@person1] == @event.attendees.to_a
+
+  @event.attendees.replace([@person2, @person3])
+
+  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")
+  {'D' => 4, 'C' => 2, 'B' => 5, 'A' => 3}.each_pair do |name, logins|
+    person = Person.create(:name => name)
+    person.increment :logins, logins
+    @event.attendees.add(person)
+  end
+end
+
+test "sort the model instances by the values provided" do
+  people = @event.attendees.sort_by(:name, :order => "ALPHA")
+  assert %w[A B C D] == people.map(&:name)
+end
+
+test "accept a number in the limit parameter" do
+  people = @event.attendees.sort_by(:name, :limit => [0, 2], :order => "ALPHA")
+  assert %w[A B] == people.map(&:name)
+end
+
+test "use the start parameter as an offset if the limit is provided" do
+  people = @event.attendees.sort_by(:name, :limit => [1, 2], :order => "ALPHA")
+  assert %w[B C] == people.map(&:name)
+end
+
+test "use counter attributes for sorting" do
+  people = @event.attendees.sort_by(:logins, :limit => [0, 3], :order => "ALPHA")
+  assert %w[C A D] == people.map(&:name)
+end
+
+test "use counter attributes for sorting with key option" do
+  people = @event.attendees.sort_by(:logins, :get => :logins, :limit => [0, 3], :order => "ALPHA")
+  assert %w[2 3 4] == people
+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"))
+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.redis.call("SREM", @user.posts.key, 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.redis.call("SREM", @user.posts.key, post.id)
+  assert !@user.posts.include?(post)
+end
+
+# Counters
+setup do
+  @event = Event.create(:name => "Ruby Tuesday")
+end
+
+test "be zero if not initialized" do
+  assert 0 == @event.votes
+end
+
+test "be able to increment a counter" do
+  @event.increment(:votes)
+  assert 1 == @event.votes
+
+  @event.increment(:votes, 2)
+  assert 3 == @event.votes
+end
+
+test "be able to decrement a counter" do
+  @event.decrement(:votes)
+  assert @event.votes == -1
+
+  @event.decrement(:votes, 2)
+  assert @event.votes == -3
+end
+
+# Comparison
+setup do
+  @user = User.create(:email => "foo")
+end
+
+test "be comparable to other instances" do
+  assert @user == User[@user.id]
+
+  assert @user != User.create
+  assert User.new != User.new
+end
+
+test "not be comparable to instances of other models" do
+  assert @user != Event.create(:name => "Ruby Tuesday")
+end
+
+test "be comparable to non-models" do
+  assert @user != 1
+  assert @user != true
+
+  # Not equal although the other object responds to #key.
+  assert @user != OpenStruct.new(:key => @user.send(:key))
+end
+
+# Debugging
+class ::Bar < Ohm::Model
+  attribute :name
+  counter :visits
+  set :friends, self
+  set :comments, self
+
+  def foo
+    bar.foo
+  end
+
+  def baz
+    bar.new.foo
+  end
+
+  def bar
+    SomeMissingConstant
+  end
+end
+
+# Models connected to different databases
+class ::Car < Ohm::Model
+  attribute :name
+
+  self.redis = Redic.new
+end
+
+class ::Make < Ohm::Model
+  attribute :name
+end
+
+setup do
+  Car.redis.call("SELECT", 15)
+end
+
+test "save to the selected database" do
+  car = Car.create(:name => "Twingo")
+  make = Make.create(:name => "Renault")
+
+  redis = Redic.new
+
+  assert ["1"] == redis.call("SMEMBERS", "Make:all")
+  assert [] == redis.call("SMEMBERS", "Car:all")
+
+  assert ["1"] == Car.redis.call("SMEMBERS", "Car:all")
+  assert [] == Car.redis.call("SMEMBERS", "Make:all")
+
+  assert car == Car[1]
+  assert make == Make[1]
+
+  Make.redis.call("FLUSHDB")
+
+  assert car == Car[1]
+  assert Make[1].nil?
+end
+
+test "allow changing the database" do
+  Car.create(:name => "Twingo")
+  assert_equal ["1"], Car.redis.call("SMEMBERS", Car.all.key)
+
+  Car.redis = Redic.new("redis://127.0.0.1:6379")
+  assert_equal [], Car.redis.call("SMEMBERS", Car.all.key)
+
+  Car.redis.call("SELECT", 15)
+  assert_equal ["1"], Car.redis.call("SMEMBERS", Car.all.key)
+end
+
+# Persistence
+test "persist attributes to a hash" do
+  event = Event.create(:name => "Redis Meetup")
+  event.increment(:votes)
+
+  assert "hash" == Ohm.redis.call("TYPE", "Event:1")
+
+  expected= %w[Event:1 Event:1:counters Event:all Event:id]
+  assert_equal expected, Ohm.redis.call("KEYS", "Event:*").sort
+
+  assert "Redis Meetup" == Event[1].name
+  assert 1 == Event[1].votes
+end
+
+# namespaced models
+test "be persisted" do
+  SomeNamespace::Foo.create(:name => "foo")
+
+  SomeNamespace::Bar.create(:foo  => SomeNamespace::Foo[1])
+
+  assert "hash" == Ohm.redis.call("TYPE", "SomeNamespace::Foo:1")
+
+  assert "foo" == SomeNamespace::Foo[1].name
+  assert "foo" == SomeNamespace::Bar[1].foo.name
+end if RUBY_VERSION >= "2.0.0"
+
+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 "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 "scripts are flushed" do
+  m = Meetup.create(:name => "Foo")
+
+  Meetup.redis.call("SCRIPT", "FLUSH")
+
+  m.update(:name => "Bar")
+
+  assert_equal m.name, Meetup[m.id].name
+end