ohm 0.1.0.rc5 → 0.1.0.rc6

data/test/json_test.rb

@@ -0,0 +1,67 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+require "json"
+
+class Venue < Ohm::Model
+  attribute :name
+
+  def validate
+    assert_present :name
+  end
+end
+
+class Programmer < Ohm::Model
+  attribute :language
+
+  def validate
+    assert_present :language
+  end
+
+  def to_hash
+    super.merge(:language => language)
+  end
+end
+
+test "export an empty hash via to_hash" do
+  person = Venue.new
+  assert Hash.new == person.to_hash
+end
+
+test "export a hash with the errors" do
+  person = Venue.new
+  person.valid?
+
+  assert Hash[:errors => [[:name, :not_present]]] == person.to_hash
+end
+
+test "export a hash with the its id" do
+  person = Venue.create(:name => "John Doe")
+  assert Hash[:id => '1'] == person.to_hash
+end
+
+test "export a hash with its id and the errors" do
+  person = Venue.create(:name => "John Doe")
+  person.name = nil
+  person.valid?
+
+  expected_hash = { :id => '1', :errors => [[:name, :not_present]] }
+
+  assert expected_hash == person.to_hash
+end
+
+test "return the merged attributes" do
+  programmer = Programmer.create(:language => "Ruby")
+  expected_hash = { :id => '1', :language => 'Ruby' }
+
+  assert expected_hash == programmer.to_hash
+end
+
+test "just be the to_hash of a model" do
+  json = JSON.parse(Programmer.create(:language => "Ruby").to_json)
+
+  assert ["id", "language"] == json.keys.sort
+  assert "1" == json["id"]
+  assert "Ruby" == json["language"]
+end

data/test/model_test.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+require File.expand_path("./helper", File.dirname(__FILE__))
+
 require "ostruct"
-require "json"
 
 class Post < Ohm::Model
   attribute :body
@@ -46,1099 +46,906 @@ module SomeNamespace
   end
 end
 
-class ModelTest < Test::Unit::TestCase
-  setup do
-    Ohm.flush
-    Logger.current.clear
-  end
-
-  context "An event initialized with a hash of attributes" do
-    should "assign the passed attributes" do
-      event = Event.new(:name => "Ruby Tuesday")
-      assert_equal event.name, "Ruby Tuesday"
-    end
-  end
-
-  context "An event created from a hash of attributes" do
-    should "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
+class Meetup < Ohm::Model
+  attribute :name
+  attribute :location
 
-    should "return the unsaved object if validation fails" do
-      assert Person.create(:name => nil).kind_of?(Person)
-    end
+  def validate
+    assert_present :name
   end
+end
 
-  context "An event updated from a hash of attributes" do
-    class Meetup < Ohm::Model
-      attribute :name
-      attribute :location
-
-      def validate
-        assert_present :name
-      end
-    end
-
-    should "assign an id and save the object" do
-      event = Meetup.create(:name => "Ruby Tuesday")
-      event.update(:name => "Ruby Meetup")
-      assert_equal "Ruby Meetup", event.name
-    end
-
-    should "return false if the validation fails" do
-      event = Meetup.create(:name => "Ruby Tuesday")
-      assert !event.update(:name => nil)
-    end
-
-    should "save the attributes in UTF8" do
-     event = Meetup.create(:name => "32° Kisei-sen")
-     assert_equal "32° Kisei-sen", Meetup[event.id].name
-    end
-
-    should "delete the attribute if set to nil" do
-      event = Meetup.create(:name => "Ruby Tuesday", :location => "Los Angeles")
-      assert_equal "Los Angeles", Meetup[event.id].location
-      assert event.update(:location => nil)
-      assert_equal nil, Meetup[event.id].location
-    end
-
-    should "delete the attribute if set to an empty string" do
-      event = Meetup.create(:name => "Ruby Tuesday", :location => "Los Angeles")
-      assert_equal "Los Angeles", Meetup[event.id].location
-      assert event.update(:location => "")
-      assert_equal nil, Meetup[event.id].location
-    end
-  end
+test "assign attributes from the hash" do
+  event = Event.new(:name => "Ruby Tuesday")
+  assert event.name == "Ruby Tuesday"
+end
 
-  context "Model definition" do
-    should "not raise if an attribute is redefined" do
-      assert_nothing_raised do
-        class RedefinedModel < Ohm::Model
-          attribute :name
-
-          silence_warnings do
-            attribute :name
-          end
-        end
-      end
-    end
+test "assign an ID and save the object" do
+  event1 = Event.create(:name => "Ruby Tuesday")
+  event2 = Event.create(:name => "Ruby Meetup")
 
-    should "not raise if a counter is redefined" do
-      assert_nothing_raised do
-        class RedefinedModel < Ohm::Model
-          counter :age
+  assert "1" == event1.id
+  assert "2" == event2.id
+end
 
-          silence_warnings do
-            counter :age
-          end
-        end
-      end
-    end
+test "return the unsaved object if validation fails" do
+  assert Person.create(:name => nil).kind_of?(Person)
+end
 
-    should "not raise if a list is redefined" do
-      assert_nothing_raised do
-        class RedefinedModel < Ohm::Model
-          list :todo, lambda { }
+test "updates attributes" do
+  event = Meetup.create(:name => "Ruby Tuesday")
+  event.update(:name => "Ruby Meetup")
+  assert "Ruby Meetup" == event.name
+end
 
-          silence_warnings do
-            list :todo, lambda { }
-          end
-        end
-      end
-    end
+test "return false if the validation fails" do
+  event = Meetup.create(:name => "Ruby Tuesday")
+  assert !event.update(:name => nil)
+end
 
-    should "not raise if a set is redefined" do
-      assert_nothing_raised do
-        class RedefinedModel < Ohm::Model
-          set :friends, lambda { }
+test "save the attributes in UTF8" do
+ event = Meetup.create(:name => "32° Kisei-sen")
+ assert "32° Kisei-sen" == Meetup[event.id].name
+end
 
-          silence_warnings do
-            set :friends, lambda { }
-          end
-        end
-      end
-    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 nil == Meetup[event.id].location
+end
 
-    should "not raise if a collection is redefined" do
-      assert_nothing_raised do
-        class RedefinedModel < Ohm::Model
-          list :toys, lambda { }
+test "delete the attribute if set to an empty string" do
+  event = Meetup.create(:name => "Ruby Tuesday", :location => "Los Angeles")
+  assert "Los Angeles" == Meetup[event.id].location
+  assert event.update(:location => "")
+  assert nil == Meetup[event.id].location
+end
 
-          silence_warnings do
-            set :toys, lambda { }
-          end
-        end
-      end
-    end
+test "not raise if an attribute is redefined" do
+  class RedefinedModel < Ohm::Model
+    attribute :name
 
-    should "not raise if a index is redefined" do
-      assert_nothing_raised do
-        class RedefinedModel < Ohm::Model
-          attribute :color
-          index :color
-          index :color
-        end
-      end
+    silence_warnings do
+      attribute :name
     end
   end
+end
 
-  context "Finding an event" do
-    setup do
-      Ohm.redis.sadd("Event:all", 1)
-      Ohm.redis.hset("Event:1", "name", "Concert")
-    end
+test "not raise if a counter is redefined" do
+  class RedefinedModel < Ohm::Model
+    counter :age
 
-    should "return an instance of Event" do
-      assert Event[1].kind_of?(Event)
-      assert_equal 1, Event[1].id
-      assert_equal "Concert", Event[1].name
+    silence_warnings do
+      counter :age
     end
   end
+end
 
-  context "Finding a user" do
-    setup do
-      Ohm.redis.sadd("User:all", 1)
-      Ohm.redis.hset("User:1", "email", "albert@example.com")
-    end
-
-    should "return an instance of User" do
-      assert User[1].kind_of?(User)
-      assert_equal 1, User[1].id
-      assert_equal "albert@example.com", User[1].email
-    end
+test "not raise if a list is redefined" do
+  class RedefinedModel < Ohm::Model
+    list :todo, lambda { }
 
-    should "allow to map key to models" do
-      assert_equal [User[1]], [1].map(&User)
+    silence_warnings do
+      list :todo, lambda { }
     end
   end
+end
 
-  context "Updating a user" do
-    setup do
-      Ohm.redis.sadd("User:all", 1)
-      Ohm.redis.set("User:1:email", "albert@example.com")
-
-      @user = User[1]
-    end
+test "not raise if a set is redefined" do
+  class RedefinedModel < Ohm::Model
+    set :friends, lambda { }
 
-    should "change its attributes" do
-      @user.email = "maria@example.com"
-      assert_equal "maria@example.com", @user.email
+    silence_warnings do
+      set :friends, lambda { }
     end
+  end
+end
 
-    should "save the new values" do
-      @user.email = "maria@example.com"
-      @user.save
-
-      @user.email = "maria@example.com"
-      @user.save
+test "not raise if a collection is redefined" do
+  class RedefinedModel < Ohm::Model
+    list :toys, lambda { }
 
-      assert_equal "maria@example.com", User[1].email
+    silence_warnings do
+      set :toys, lambda { }
     end
   end
+end
 
-  context "Creating a new model" do
-    should "assign a new id to the event" do
-      event1 = Event.new
-      event1.create
-
-      event2 = Event.new
-      event2.create
-
-      assert !event1.new?
-      assert !event2.new?
-
-      assert_equal "1", event1.id
-      assert_equal "2", event2.id
-    end
+test "not raise if a index is redefined" do
+  class RedefinedModel < Ohm::Model
+    attribute :color
+    index :color
+    index :color
   end
+end
 
-  context "Saving a model" do
-    should "create the model if it is new" do
-      event = Event.new(:name => "Foo").save
-      assert_equal "Foo", Event[event.id].name
-    end
+test "allow arbitrary IDs" do
+  Event.create(:id => "abc123", :name => "Concert")
 
-    should "save it only if it was previously created" do
-      event = Event.new
-      event.name = "Lorem ipsum"
-      event.create
+  assert Event.all.size == 1
+  assert Event["abc123"].name == "Concert"
+end
 
-      event.name = "Lorem"
-      event.save
+setup do
+  Ohm.redis.sadd("Event:all", 1)
+  Ohm.redis.hset("Event:1", "name", "Concert")
+end
 
-      assert_equal "Lorem", Event[event.id].name
-    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
 
-    should "allow to hook into write" do
-      event = Event.create(:name => "Foo")
+setup do
+  Ohm.redis.sadd("User:all", 1)
+  Ohm.redis.hset("User:1", "email", "albert@example.com")
+end
 
-      assert_equal "foo", event.slug
-    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
 
-    should "save counters" do
-      event = Event.create(:name => "Foo")
+test "allow to map key to models" do
+  assert [User[1]] == [1].map(&User)
+end
 
-      event.incr(:votes)
-      event.save
+setup do
+  Ohm.redis.sadd("User:all", 1)
+  Ohm.redis.set("User:1:email", "albert@example.com")
 
-      assert_equal 1, Event[event.id].votes
-    end
+  @user = User[1]
+end
 
-  end
+test "change its attributes" do
+  @user.email = "maria@example.com"
+  assert "maria@example.com" == @user.email
+end
 
-  context "Delete" do
-    should "delete an existing model" do
-      class ModelToBeDeleted < Ohm::Model
-        attribute :name
-        set :foos, Post
-        list :bars, Post
-      end
+test "save the new values" do
+  @user.email = "maria@example.com"
+  @user.save
 
-      @model = ModelToBeDeleted.create(:name => "Lorem")
+  @user.email = "maria@example.com"
+  @user.save
 
-      @model.foos << Post.create
-      @model.bars << Post.create
+  assert "maria@example.com" == User[1].email
+end
 
-      id = @model.id
+test "assign a new id to the event" do
+  event1 = Event.new
+  event1.create
 
-      @model.delete
+  event2 = Event.new
+  event2.create
 
-      assert_nil Ohm.redis.get(ModelToBeDeleted.key[id])
-      assert_nil Ohm.redis.get(ModelToBeDeleted.key[id][:name])
-      assert_equal Array.new, Ohm.redis.smembers(ModelToBeDeleted.key[id][:foos])
-      assert_equal Array.new, Ohm.redis.lrange(ModelToBeDeleted.key[id][:bars], 0, -1)
+  assert !event1.new?
+  assert !event2.new?
 
-      assert ModelToBeDeleted.all.empty?
-    end
+  assert "1" == event1.id
+  assert "2" == event2.id
+end
 
-    should "be no leftover keys" do
-      class ::Foo < Ohm::Model
-        attribute :name
-        index :name
-      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
 
-      assert_equal [], Ohm.redis.keys("*")
+test "save it only if it was previously created" do
+  event = Event.new
+  event.name = "Lorem ipsum"
+  event.create
 
-      Foo.create(:name => "Bar")
+  event.name = "Lorem"
+  event.save
 
-      assert_equal ["Foo:1:_indices", "Foo:1", "Foo:all", "Foo:id", "Foo:name:QmFy"].sort, Ohm.redis.keys("*").sort
+  assert "Lorem" == Event[event.id].name
+end
 
-      Foo[1].delete
+test "allow to hook into write" do
+  event = Event.create(:name => "Foo")
 
-      assert_equal ["Foo:id"], Ohm.redis.keys("*")
-    end
-  end
+  assert "foo" == event.slug
+end
 
-  context "Listing" do
-    should "find all" do
-      event1 = Event.new
-      event1.name = "Ruby Meetup"
-      event1.create
+test "save counters" do
+  event = Event.create(:name => "Foo")
 
-      event2 = Event.new
-      event2.name = "Ruby Tuesday"
-      event2.create
+  event.incr(:votes)
+  event.save
 
-      all = Event.all
+  assert 1 == Event[event.id].votes
+end
 
-      assert all.detect {|e| e.name == "Ruby Meetup" }
-      assert all.detect {|e| e.name == "Ruby Tuesday" }
-    end
+# Delete
+test "delete an existing model" do
+  class ModelToBeDeleted < Ohm::Model
+    attribute :name
+    set :foos, Post
+    list :bars, Post
   end
 
-  context "Sorting" do
-    should "sort all" do
-      Person.create :name => "D"
-      Person.create :name => "C"
-      Person.create :name => "B"
-      Person.create :name => "A"
-
-      assert_equal %w[A B C D], Person.all.sort_by(:name, :order => "ALPHA").map { |person| person.name }
-    end
-
-    should "return an empty array if there are no elements to sort" do
-      assert_equal [], Person.all.sort_by(:name)
-    end
-
-    should "return the first element sorted by id when using first" do
-      Person.create :name => "A"
-      Person.create :name => "B"
-      assert_equal "A", Person.all.first.name
-    end
-
-    should "return the first element sorted by name if first receives a sorting option" do
-      Person.create :name => "B"
-      Person.create :name => "A"
-      assert_equal "A", Person.all.first(:by => :name, :order => "ALPHA").name
-    end
-
-    should "return attribute values when the get parameter is specified" do
-      Person.create :name => "B"
-      Person.create :name => "A"
-
-      assert_equal "A", Person.all.sort_by(:name, :get => :name, :order => "ALPHA").first
-    end
-  end
+  @model = ModelToBeDeleted.create(:name => "Lorem")
 
-  context "Loading attributes" do
-    setup do
-      event = Event.new
-      event.name = "Ruby Tuesday"
-      @id = event.create.id
-    end
+  @model.foos << Post.create
+  @model.bars << Post.create
 
-    should "load attributes lazily" do
-      event = Event[@id]
+  id = @model.id
 
-      Logger.current.clear
+  @model.delete
 
-      assert Logger.current.commands.empty?
-      assert_equal "Ruby Tuesday", event.name
-      assert !Logger.current.commands.empty?
+  assert Ohm.redis.get(ModelToBeDeleted.key[id]).nil?
+  assert Ohm.redis.get(ModelToBeDeleted.key[id][:name]).nil?
+  assert Array.new == Ohm.redis.smembers(ModelToBeDeleted.key[id][:foos])
+  assert Array.new == Ohm.redis.lrange(ModelToBeDeleted.key[id][:bars], 0, -1)
 
-      Logger.current.clear
-      assert_equal "Ruby Tuesday", event.name
-      assert Logger.current.commands.empty?
-    end
+  assert ModelToBeDeleted.all.empty?
+end
 
-    should "load attributes as a strings" do
-      event = Event.create(:name => 1)
+setup do
+end
 
-      assert_equal "1", Event[event.id].name
-    end
+test "be no leftover keys" do
+  class ::Foo < Ohm::Model
+    attribute :name
+    index :name
   end
 
-  context "Attributes of type Set" do
-    setup do
-      @person1 = Person.create(:name => "Albert")
-      @person2 = Person.create(:name => "Bertrand")
-      @person3 = Person.create(:name => "Charles")
+  assert [] == Ohm.redis.keys("*")
 
-      @event = Event.new
-      @event.name = "Ruby Tuesday"
-    end
+  Foo.create(:name => "Bar")
 
-    should "not be available if the model is new" do
-      assert_raise Ohm::Model::MissingID do
-        @event.attendees << Person.new
-      end
-    end
+  assert ["Foo:1:_indices", "Foo:1", "Foo:all", "Foo:id", "Foo:name:QmFy"].sort == Ohm.redis.keys("*").sort
 
-    should "remove an element if sent delete" do
-      @event.create
-      @event.attendees << @person1
-      @event.attendees << @person2
-      @event.attendees << @person3
-      assert_equal ["1", "2", "3"], @event.attendees.key.sort
-      @event.attendees.delete(@person2)
-      assert_equal ["1", "3"], Event[@event.id].attendees.key.sort
-    end
-
-    should "return true if the set includes some member" do
-      @event.create
-      @event.attendees << @person1
-      @event.attendees << @person2
-      assert @event.attendees.include?(@person2)
-      assert !@event.attendees.include?(@person3)
-    end
+  Foo[1].delete
 
-    should "return instances of the passed model" do
-      @event.create
-      @event.attendees << @person1
-
-      assert_equal [@person1], @event.attendees.all
-      assert_equal @person1, @event.attendees[@person1.id]
-    end
+  assert ["Foo:id"] == Ohm.redis.keys("*")
+end
 
-    should "return the size of the set" do
-      @event.create
-      @event.attendees << @person1
-      @event.attendees << @person2
-      @event.attendees << @person3
-      assert_equal 3, @event.attendees.size
-    end
+# Listing
+test "find all" do
+  event1 = Event.new
+  event1.name = "Ruby Meetup"
+  event1.create
 
-    should "empty the set" do
-      @event.create
-      @event.attendees << @person1
+  event2 = Event.new
+  event2.name = "Ruby Tuesday"
+  event2.create
 
-      @event.attendees.clear
+  all = Event.all
 
-      assert @event.attendees.empty?
-    end
+  assert all.detect {|e| e.name == "Ruby Meetup" }
+  assert all.detect {|e| e.name == "Ruby Tuesday" }
+end
 
-    should "replace the values in the set" do
-      @event.create
-      @event.attendees << @person1
+# Sorting
+test "sort all" do
+  Person.create :name => "D"
+  Person.create :name => "C"
+  Person.create :name => "B"
+  Person.create :name => "A"
 
-      assert_equal [@person1], @event.attendees.all
+  assert %w[A B C D] == Person.all.sort_by(:name, :order => "ALPHA").map { |person| person.name }
+end
 
-      @event.attendees.replace([@person2, @person3])
+test "return an empty array if there are no elements to sort" do
+  assert [] == Person.all.sort_by(:name)
+end
 
-      assert_equal [@person2, @person3], @event.attendees.all.sort_by(&:id)
-    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
 
-    should "filter elements" do
-      @event.create
-      @event.attendees.add(@person1)
-      @event.attendees.add(@person2)
+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
 
-      assert_equal [@person1], @event.attendees.find(:initial => "A").all
-      assert_equal [@person2], @event.attendees.find(:initial => "B").all
-      assert_equal [],    @event.attendees.find(:initial => "Z").all
-    end
-  end
+test "return attribute values when the get parameter is specified" do
+  Person.create :name => "B"
+  Person.create :name => "A"
 
-  context "Attributes of type List" do
-    setup do
-      @post = Post.new
-      @post.body = "Hello world!"
-      @post.create
-    end
+  assert "A" == Person.all.sort_by(:name, :get => :name, :order => "ALPHA").first
+end
 
-    should "return an array" do
-      assert @post.related.all.kind_of?(Array)
-    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")
 
-    should "append elements with push" do
-      @post.related.push Post.create
-      @post.related << Post.create
+  assert ["A", "B", "C"] == @post.related.sort_by(:body, :order => "ALPHA ASC").map { |model| model.body }
+end
 
-      assert_equal ["2", "3"], @post.related.all.map { |model| model.id }
-    end
+# Loading attributes
+setup do
+  event = Event.new
+  event.name = "Ruby Tuesday"
+  @id = event.create.id
+end
 
-    should "keep the inserting order" do
-      @post.related << Post.create
-      @post.related << Post.create
-      @post.related << Post.create
-      assert_equal ["2", "3", "4"], @post.related.all.map { |model| model.id }
-    end
+def monitor
+  log = []
 
-    should "keep the inserting order after saving" do
-      @post.related << Post.create
-      @post.related << Post.create
-      @post.related << Post.create
-      @post.save
-      assert_equal ["2", "3", "4"], Post[@post.id].related.map { |model| model.id }
+  monitor = Thread.new do
+    Redis.connect.monitor do |line|
+      break if line =~ /ping/
+      log << line
     end
+  end
 
-    should "allow slicing the list" do
-      post1 = Post.create
-      post2 = Post.create
-      post3 = Post.create
-
-      @post.related << post1
-      @post.related << post2
-      @post.related << post3
+  sleep 0.01
 
-      assert_equal post1, @post.related[0]
-      assert_equal post2, @post.related[1]
-      assert_equal post3, @post.related[-1]
+  log.clear.tap do
+    yield
+    Ohm.redis.ping
+    monitor.join
+  end
+end
 
-      assert_equal nil, @post.related[3]
+test "load attributes lazily" do
+  event = Event[@id]
 
-      assert_equal [post2, post3], @post.related[1, 2]
-      assert_equal [post2, post3], @post.related[1, -1]
+  log = monitor { event.name }
 
-      assert_equal [], @post.related[4, 5]
+  assert !log.empty?
 
-      assert_equal [post2, post3], @post.related[1..2]
-      assert_equal [post2, post3], @post.related[1..5]
+  log = monitor { event.name }
 
-      assert_equal [], @post.related[4..5]
-    end
+  assert log.empty?
+end
 
-    should "respond to each" do
-      @post.related << Post.create
-      @post.related << Post.create
-      @post.related << Post.create
+test "load attributes as a strings" do
+  event = Event.create(:name => 1)
 
-      i = 2
-      @post.related.each do |c|
-        assert_equal i, c.id.to_i
-        i += 1
-      end
-    end
+  assert "1" == Event[event.id].name
+end
 
-    should "return the size of the list" do
-      @post.related << Post.create
-      @post.related << Post.create
-      @post.related << Post.create
-      assert_equal 3, @post.related.size
-    end
+# Attributes of type Set
+setup do
+  @person1 = Person.create(:name => "Albert")
+  @person2 = Person.create(:name => "Bertrand")
+  @person3 = Person.create(:name => "Charles")
 
-    should "return the last element with pop" do
-      @post.related << Post.create
-      @post.related << Post.create
-      assert_equal "3", @post.related.pop.id
-      assert_equal "2", @post.related.pop.id
-      assert @post.related.empty?
-    end
+  @event = Event.new
+  @event.name = "Ruby Tuesday"
+end
 
-    should "return the first element with shift" do
-      @post.related << Post.create
-      @post.related << Post.create
-      assert_equal "2", @post.related.shift.id
-      assert_equal "3", @post.related.shift.id
-      assert @post.related.empty?
-    end
+test "not be available if the model is new" do
+  assert_raise Ohm::Model::MissingID do
+    @event.attendees << Person.new
+  end
+end
 
-    should "push to the head of the list with unshift" do
-      @post.related.unshift Post.create
-      @post.related.unshift Post.create
-      assert_equal "2", @post.related.pop.id
-      assert_equal "3", @post.related.pop.id
-      assert @post.related.empty?
-    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
+end
 
-    should "empty the list" do
-      @post.related.unshift Post.create
-      @post.related.clear
+test "return true if the set includes some member" do
+  @event.create
+  @event.attendees << @person1
+  @event.attendees << @person2
+  assert @event.attendees.include?(@person2)
+  assert !@event.attendees.include?(@person3)
+end
 
-      assert @post.related.empty?
-    end
+test "return instances of the passed model" do
+  @event.create
+  @event.attendees << @person1
 
-    should "replace the values in the list" do
-      @post.related.replace([Post.create, Post.create])
+  assert [@person1] == @event.attendees.all
+  assert @person1 == @event.attendees[@person1.id]
+end
 
-      assert_equal ["2", "3"], @post.related.map { |model| model.id }
-    end
+test "return the size of the set" do
+  @event.create
+  @event.attendees << @person1
+  @event.attendees << @person2
+  @event.attendees << @person3
+  assert 3 == @event.attendees.size
+end
 
-    should "add models" do
-      @post.related.add(Post.create(:body => "Hello"))
-      assert_equal ["2"], @post.related.map { |model| model.id }
-    end
+test "empty the set" do
+  @event.create
+  @event.attendees << @person1
 
-    should "find elements in the list" do
-      another_post = Post.create
+  @event.attendees.clear
 
-      @post.related.add(another_post)
+  assert @event.attendees.empty?
+end
 
-      assert  @post.related.include?(another_post)
-      assert !@post.related.include?(Post.create)
-    end
+test "replace the values in the set" do
+  @event.create
+  @event.attendees << @person1
 
-    should "unshift models" do
-      @post.related.unshift(Post.create(:body => "Hello"))
-      @post.related.unshift(Post.create(:body => "Goodbye"))
+  assert [@person1] == @event.attendees.all
 
-      assert_equal ["3", "2"], @post.related.map { |model| model.id }
+  @event.attendees.replace([@person2, @person3])
 
-      assert_equal "3", @post.related.shift.id
+  assert [@person2, @person3] == @event.attendees.all.sort_by(&:id)
+end
 
-      assert_equal "2", @post.related.pop.id
+test "filter elements" do
+  @event.create
+  @event.attendees.add(@person1)
+  @event.attendees.add(@person2)
 
-      assert_nil @post.related.pop
-    end
-  end
+  assert [@person1] == @event.attendees.find(:initial => "A").all
+  assert [@person2] == @event.attendees.find(:initial => "B").all
+  assert [] == @event.attendees.find(:initial => "Z").all
+end
 
-  context "Applying arbitrary transformations" do
-    require "date"
+# Attributes of type List
+setup do
+  @post = Post.new
+  @post.body = "Hello world!"
+  @post.create
+end
 
-    class MyActiveRecordModel
-      def self.find(id)
-        return new if id.to_i == 1
-      end
+test "return an array" do
+  assert @post.related.all.kind_of?(Array)
+end
 
-      def id
-        1
-      end
+test "append elements with push" do
+  @post.related.push Post.create
+  @post.related << Post.create
 
-      def ==(other)
-        id == other.id
-      end
-    end
+  assert ["2", "3"] == @post.related.all.map { |model| model.id }
+end
 
-    class ::Calendar < Ohm::Model
-      list :holidays, lambda { |v| Date.parse(v) }
-      list :subscribers, lambda { |id| MyActiveRecordModel.find(id) }
-      list :appointments, Appointment
-    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
 
-    class ::Appointment < Ohm::Model
-      attribute :text
-      reference :subscriber, lambda { |id| MyActiveRecordModel.find(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
 
-    setup do
-      @calendar = Calendar.create
+test "allow slicing the list" do
+  post1 = Post.create
+  post2 = Post.create
+  post3 = Post.create
 
-      @calendar.holidays.key.rpush "2009-05-25"
-      @calendar.holidays.key.rpush "2009-07-09"
+  @post.related << post1
+  @post.related << post2
+  @post.related << post3
 
-      @calendar.subscribers << MyActiveRecordModel.find(1)
-    end
+  assert post1 == @post.related[0]
+  assert post2 == @post.related[1]
+  assert post3 == @post.related[-1]
 
-    should "apply a transformation" do
-      assert_equal [Date.new(2009, 5, 25), Date.new(2009, 7, 9)], @calendar.holidays.all
+  assert nil == @post.related[3]
 
-      assert_equal [1], @calendar.subscribers.all.map { |model| model.id }
-      assert_equal [MyActiveRecordModel.find(1)], @calendar.subscribers.all
-    end
+  assert [post2, post3] == @post.related[1, 2]
+  assert [post2, post3] == @post.related[1, -1]
 
-    should "allow lambdas in references" do
-      appointment = Appointment.create(:subscriber => MyActiveRecordModel.find(1))
-      assert_equal MyActiveRecordModel.find(1), appointment.subscriber
-    end
+  assert [] == @post.related[4, 5]
 
-    should "work with models too" do
-      @calendar.appointments.add(Appointment.create(:text => "Meet with Bertrand"))
+  assert [post2, post3] == @post.related[1..2]
+  assert [post2, post3] == @post.related[1..5]
 
-      assert_equal [Appointment[1]], Calendar[1].appointments.sort
-    end
-  end
+  assert [] == @post.related[4..5]
+end
 
-  context "Sorting lists and sets" do
-    setup do
-      @post = Post.create(:body => "Lorem")
-      @post.related << Post.create
-      @post.related << Post.create
-      @post.related << Post.create
-    end
+test "respond to each" do
+  @post.related << Post.create
+  @post.related << Post.create
+  @post.related << Post.create
 
-    should "sort values" do
-      assert_equal %w{2 3 4}, @post.related.sort.map { |model| model.id }
-    end
+  i = 2
+  @post.related.each do |c|
+    assert i == c.id.to_i
+    i += 1
   end
+end
 
-  context "Sorting lists and sets by model attributes" do
-    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")
-    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
 
-    should "sort the model instances by the values provided" do
-      people = @event.attendees.sort_by(:name, :order => "ALPHA")
-      assert_equal %w[A B C D], people.map { |person| person.name }
-    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
 
-    should "accept a number in the limit parameter" do
-      people = @event.attendees.sort_by(:name, :limit => 2, :order => "ALPHA")
-      assert_equal %w[A B], people.map { |person| person.name }
-    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
 
-    should "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")
-      assert_equal %w[B C], people.map { |person| person.name }
-    end
-  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
 
-  context "Collections initialized with a Model parameter" do
-    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 "empty the list" do
+  @post.related.unshift Post.create
+  @post.related.clear
 
-    should "return instances of the passed model" do
-      assert_equal Post, @user.posts.first.class
-    end
-  end
+  assert @post.related.empty?
+end
 
-  context "Counters" do
-    setup do
-      @event = Event.create(:name => "Ruby Tuesday")
-    end
+test "replace the values in the list" do
+  @post.related.replace([Post.create, Post.create])
 
-    should "raise ArgumentError if the attribute is not a counter" do
-      assert_raise ArgumentError do
-        @event.incr(:name)
-      end
-    end
+  assert ["2", "3"] == @post.related.map { |model| model.id }
+end
 
-    should "be zero if not initialized" do
-      assert_equal 0, @event.votes
-    end
+test "add models" do
+  @post.related.add(Post.create(:body => "Hello"))
+  assert ["2"] == @post.related.map { |model| model.id }
+end
 
-    should "be able to increment a counter" do
-      @event.incr(:votes)
-      assert_equal 1, @event.votes
+test "find elements in the list" do
+  another_post = Post.create
 
-      @event.incr(:votes, 2)
-      assert_equal 3, @event.votes
-    end
+  @post.related.add(another_post)
 
-    should "be able to decrement a counter" do
-      @event.decr(:votes)
-      assert_equal(-1, @event.votes)
+  assert  @post.related.include?(another_post)
+  assert !@post.related.include?(Post.create)
+end
 
-      @event.decr(:votes, 2)
-      assert_equal(-3, @event.votes)
-    end
-  end
+test "unshift models" do
+  @post.related.unshift(Post.create(:body => "Hello"))
+  @post.related.unshift(Post.create(:body => "Goodbye"))
 
-  context "Comparison" do
-    setup do
-      @user = User.create(:email => "foo")
-    end
+  assert ["3", "2"] == @post.related.map { |model| model.id }
 
-    should "be comparable to other instances" do
-      assert_equal @user, User[@user.id]
+  assert "3" == @post.related.shift.id
 
-      assert_not_equal @user, User.create
-      assert_not_equal User.new, User.new
-    end
+  assert "2" == @post.related.pop.id
 
-    should "not be comparable to instances of other models" do
-      assert_not_equal @user, Event.create(:name => "Ruby Tuesday")
-    end
+  assert @post.related.pop.nil?
+end
 
-    should "be comparable to non-models" do
-      assert_not_equal @user, 1
-      assert_not_equal @user, true
+# Applying arbitrary transformations
+require "date"
 
-      # Not equal although the other object responds to #key.
-      assert_not_equal @user, OpenStruct.new(:key => @user.send(:key))
-    end
+class MyActiveRecordModel
+  def self.find(id)
+    return new if id.to_i == 1
   end
 
-  context "Debugging" do
-    class ::Bar < Ohm::Model
-      attribute :name
-      counter :visits
-      set :friends, self
-      list :comments, self
-
-      def foo
-        bar.foo
-      end
-
-      def baz
-        bar.new.foo
-      end
+  def id
+    1
+  end
 
-      def bar
-        SomeMissingConstant
-      end
-    end
+  def ==(other)
+    id == other.id
+  end
+end
 
-    should "provide a meaningful inspect" do
-      bar = Bar.new
+class ::Calendar < Ohm::Model
+  list :holidays, lambda { |v| Date.parse(v) }
+  list :subscribers, lambda { |id| MyActiveRecordModel.find(id) }
+  list :appointments, Appointment
+end
 
-      assert_equal "#<Bar:? name=nil friends=nil comments=nil visits=0>", bar.inspect
+class ::Appointment < Ohm::Model
+  attribute :text
+  reference :subscriber, lambda { |id| MyActiveRecordModel.find(id) }
+end
 
-      bar.update(:name => "Albert")
-      bar.friends << Bar.create
-      bar.friends << Bar.create
-      bar.comments << Bar.create
-      bar.incr(:visits)
+setup do
+  @calendar = Calendar.create
 
-      assert_equal %Q{#<Bar:#{bar.id} name="Albert" friends=#<Set (Bar): ["3", "2"]> comments=#<List (Bar): ["4"]> visits=1>}, Bar[bar.id].inspect
-    end
+  @calendar.holidays.key.rpush "2009-05-25"
+  @calendar.holidays.key.rpush "2009-07-09"
 
-    def assert_wrapper_exception(&block)
-      begin
-        block.call
-      rescue NoMethodError => exception_raised
-      end
+  @calendar.subscribers << MyActiveRecordModel.find(1)
+end
 
-      assert_match(/You tried to call SomeMissingConstant#\w+, but SomeMissingConstant is not defined on #{__FILE__}:\d+:in `bar'/, exception_raised.message)
-    end
+test "apply a transformation" do
+  assert [Date.new(2009, 5, 25), Date.new(2009, 7, 9)] == @calendar.holidays.all
 
-    should "inform about a miscatch by Wrapper when calling class methods" do
-      assert_wrapper_exception { Bar.new.baz }
-    end
+  assert [1] == @calendar.subscribers.all.map { |model| model.id }
+  assert [MyActiveRecordModel.find(1)] == @calendar.subscribers.all
+end
 
-    should "inform about a miscatch by Wrapper when calling instance methods" do
-      assert_wrapper_exception { Bar.new.foo }
-    end
-  end
+test "allow lambdas in references" do
+  appointment = Appointment.create(:subscriber => MyActiveRecordModel.find(1))
+  assert MyActiveRecordModel.find(1) == appointment.subscriber
+end
 
-  context "Overwriting write" do
-    class ::Baz < Ohm::Model
-      attribute :name
+test "work with models too" do
+  @calendar.appointments.add(Appointment.create(:text => "Meet with Bertrand"))
 
-      def write
-        self.name = "Foobar"
-        super
-      end
-    end
+  assert [Appointment[1]] == Calendar[1].appointments.sort
+end
 
-    should "work properly" do
-      baz = Baz.new
-      baz.name = "Foo"
-      baz.save
-      baz.name = "Foo"
-      baz.save
-      assert_equal "Foobar", Baz[baz.id].name
-    end
-  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
 
-  context "References to other objects" do
-    class ::Note < Ohm::Model
-      attribute :content
-      reference :source, Post
-      collection :comments, Comment
-      list :ratings, Rating
-    end
+test "sort values" do
+  assert %w{2 3 4} == @post.related.sort.map { |model| model.id }
+end
 
-    class ::Comment < Ohm::Model
-      reference :note, Note
-    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")
+end
 
-    class ::Rating < Ohm::Model
-      attribute :value
-    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 { |person| person.name }
+end
 
-    class ::Editor < Ohm::Model
-      attribute :name
-      reference :post, Post
-    end
+test "accept a number in the limit parameter" do
+  people = @event.attendees.sort_by(:name, :limit => 2, :order => "ALPHA")
+  assert %w[A B] == people.map { |person| person.name }
+end
 
-    class ::Post < Ohm::Model
-      reference :author, Person
-      collection :notes, Note, :source
-      collection :editors, Editor
-    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")
+  assert %w[B C] == people.map { |person| person.name }
+end
 
-    setup do
-      @post = Post.create
-    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
 
-    context "a reference to another object" do
-      should "return an instance of Person if author_id has a valid id" do
-        @post.author_id = Person.create(:name => "Albert").id
-        @post.save
-        assert_equal "Albert", Post[@post.id].author.name
-      end
+test "return instances of the passed model" do
+  assert Post == @user.posts.first.class
+end
 
-      should "assign author_id if author is sent a valid instance" do
-        @post.author = Person.create(:name => "Albert")
-        @post.save
-        assert_equal "Albert", Post[@post.id].author.name
-      end
+# Counters
+setup do
+  @event = Event.create(:name => "Ruby Tuesday")
+end
 
-      should "assign nil if nil is passed to author" do
-        @post.author = nil
-        @post.save
-        assert_nil Post[@post.id].author
-      end
+test "raise ArgumentError if the attribute is not a counter" do
+  assert_raise ArgumentError do
+    @event.incr(:name)
+  end
+end
 
-      should "be cached in an instance variable" do
-        @author = Person.create(:name => "Albert")
-        @post.update(:author => @author)
+test "be zero if not initialized" do
+  assert 0 == @event.votes
+end
 
-        assert_equal @author, @post.author
-        assert @post.author.object_id == @post.author.object_id
+test "be able to increment a counter" do
+  @event.incr(:votes)
+  assert 1 == @event.votes
 
-        @post.update(:author => Person.create(:name => "Bertrand"))
+  @event.incr(:votes, 2)
+  assert 3 == @event.votes
+end
 
-        assert_equal "Bertrand", @post.author.name
-        assert @post.author.object_id == @post.author.object_id
+test "be able to decrement a counter" do
+  @event.decr(:votes)
+  assert @event.votes == -1
 
-        @post.update(:author_id => Person.create(:name => "Charles").id)
+  @event.decr(:votes, 2)
+  assert @event.votes == -3
+end
 
-        assert_equal "Charles", @post.author.name
-      end
-    end
+# Comparison
+setup do
+  @user = User.create(:email => "foo")
+end
 
-    context "a collection of other objects" do
-      setup do
-        @note = Note.create(:content => "Interesting stuff", :source => @post)
-        @comment = Comment.create(:note => @note)
-      end
+test "be comparable to other instances" do
+  assert @user == User[@user.id]
 
-      should "return a set of notes" do
-        assert_equal @note.source, @post
-        assert_equal @note, @post.notes.first
-      end
+  assert @user != User.create
+  assert User.new != User.new
+end
 
-      should "return a set of comments" do
-        assert_equal @comment, @note.comments.first
-      end
+test "not be comparable to instances of other models" do
+  assert @user != Event.create(:name => "Ruby Tuesday")
+end
 
-      should "return a list of ratings" do
-        @rating = Rating.create(:value => 5)
-        @note.ratings << @rating
+test "be comparable to non-models" do
+  assert @user != 1
+  assert @user != true
 
-        assert_equal @rating, @note.ratings.first
-      end
+  # Not equal although the other object responds to #key.
+  assert @user != OpenStruct.new(:key => @user.send(:key))
+end
 
-      should "default to the current class name" do
-        @editor = Editor.create(:name => "Albert", :post => @post)
+# Debugging
+class ::Bar < Ohm::Model
+  attribute :name
+  counter :visits
+  set :friends, self
+  list :comments, self
 
-        assert_equal @editor, @post.editors.first
-      end
-    end
+  def foo
+    bar.foo
   end
 
-  context "Models connected to different databases" do
-    class ::Car < Ohm::Model
-      attribute :name
-    end
-
-    class ::Make < Ohm::Model
-      attribute :name
-    end
+  def baz
+    bar.new.foo
+  end
 
-    setup do
-      Car.connect(:db => 15)
-      Car.db.flushdb
-    end
+  def bar
+    SomeMissingConstant
+  end
+end
 
-    should "save to the selected database" do
-      car = Car.create(:name => "Twingo")
-      make = Make.create(:name => "Renault")
+test "provide a meaningful inspect" do
+  bar = Bar.new
 
-      assert_equal ["1"], Redis.connect.smembers("Make:all")
-      assert_equal [], Redis.connect.smembers("Car:all")
+  assert "#<Bar:? name=nil friends=nil comments=nil visits=0>" == bar.inspect
 
-      assert_equal ["1"], Car.db.smembers("Car:all")
-      assert_equal [], Car.db.smembers("Make:all")
+  bar.update(:name => "Albert")
+  bar.friends << Bar.create
+  bar.comments << Bar.create
+  bar.incr(:visits)
 
-      assert_equal car, Car[1]
-      assert_equal make, Make[1]
+  assert %Q{#<Bar:#{bar.id} name="Albert" friends=#<Set (Bar): ["2"]> comments=#<List (Bar): ["3"]> visits=1>} == Bar[bar.id].inspect
+end
 
-      Make.db.flushdb
+def assert_wrapper_exception(&block)
+  begin
+    block.call
+  rescue NoMethodError => exception_raised
+  end
 
-      assert_equal car, Car[1]
-      assert_nil Make[1]
-    end
+  assert exception_raised.message =~
+  /You tried to call SomeMissingConstant#\w+, but SomeMissingConstant is not defined on #{__FILE__}:\d+:in `bar'/
+end
 
-    should "allow changing the database" do
-      Car.create(:name => "Twingo")
+test "inform about a miscatch by Wrapper when calling class methods" do
+  assert_wrapper_exception { Bar.new.baz }
+end
 
-      assert_equal ["1"], Car.all.key.smembers
+test "inform about a miscatch by Wrapper when calling instance methods" do
+  assert_wrapper_exception { Bar.new.foo }
+end
 
-      Car.connect
-      assert_equal [], Car.all.key.smembers
+# Overwriting write
+class ::Baz < Ohm::Model
+  attribute :name
 
-      Car.connect :db => 15
-      assert_equal ["1"], Car.all.key.smembers
-    end
+  def write
+    self.name = "Foobar"
+    super
   end
+end
 
-  context "Persistence" do
-    should "persist attributes to a hash" do
-      event = Event.create(:name => "Redis Meetup")
-      event.incr(:votes)
+test "work properly" do
+  baz = Baz.new
+  baz.name = "Foo"
+  baz.save
+  baz.name = "Foo"
+  baz.save
+  assert "Foobar" == Baz[baz.id].name
+end
 
-      assert_equal "hash", Ohm.redis.type("Event:1")
+# Models connected to different databases
+class ::Car < Ohm::Model
+  attribute :name
+end
 
-      assert_equal [
-        "Event:1", "Event:all", "Event:id"
-      ].sort, Ohm.redis.keys("Event:*").sort
+class ::Make < Ohm::Model
+  attribute :name
+end
 
-      assert_equal "Redis Meetup", Event[1].name
-      assert_equal 1, Event[1].votes
-    end
-  end
+setup do
+  Car.connect(:db => 15)
+  Car.db.flushdb
+end
 
-  context "Exporting" do
-    class Venue < Ohm::Model
-      attribute :name
+test "save to the selected database" do
+  car = Car.create(:name => "Twingo")
+  make = Make.create(:name => "Renault")
 
-      def validate
-        assert_present :name
-      end
-    end
+  assert ["1"] == Redis.connect.smembers("Make:all")
+  assert [] == Redis.connect.smembers("Car:all")
 
-    context "a new model without errors" do
-      should "export an empty hash via to_hash" do
-        person = Venue.new
-        assert_equal({}, person.to_hash)
-      end
-    end
+  assert ["1"] == Car.db.smembers("Car:all")
+  assert [] == Car.db.smembers("Make:all")
 
-    context "a new model with some errors" do
-      should "export a hash with the errors" do
-        person = Venue.new
-        person.valid?
+  assert car == Car[1]
+  assert make == Make[1]
 
-        assert_equal({ :errors => [[:name, :not_present]] }, person.to_hash)
-      end
-    end
+  Make.db.flushdb
 
-    context "an existing model" do
-      should "export a hash with the its id" do
-        person = Venue.create(:name => "John Doe")
-        assert_equal({ :id => '1' }, person.to_hash)
-      end
-    end
+  assert car == Car[1]
+  assert Make[1].nil?
+end
 
-    context "an existing model with validation errors" do
-      should "export a hash with its id and the errors" do
-        person = Venue.create(:name => "John Doe")
-        person.name = nil
-        person.valid?
+test "allow changing the database" do
+  Car.create(:name => "Twingo")
 
-        expected_hash = { :id => '1', :errors => [[:name, :not_present]] }
+  assert ["1"] == Car.all.key.smembers
 
-        assert_equal expected_hash, person.to_hash
-      end
-    end
+  Car.connect
+  assert [] == Car.all.key.smembers
 
-    class Programmer < Ohm::Model
-      attribute :language
+  Car.connect :db => 15
+  assert ["1"] == Car.all.key.smembers
+end
 
-      def validate
-        assert_present :language
-      end
+# Persistence
+test "persist attributes to a hash" do
+  event = Event.create(:name => "Redis Meetup")
+  event.incr(:votes)
 
-      def to_hash
-        super.merge(:language => language)
-      end
-    end
+  assert "hash" == Ohm.redis.type("Event:1")
 
-    context "a subclassed to_hash" do
-      should "return the merged attributes" do
-        programmer = Programmer.create(:language => "Ruby")
-        expected_hash = { :id => '1', :language => 'Ruby' }
+  assert [
+    "Event:1", "Event:all", "Event:id"
+  ].sort == Ohm.redis.keys("Event:*").sort
 
-        assert_equal expected_hash, programmer.to_hash
-      end
-    end
+  assert "Redis Meetup" == Event[1].name
+  assert 1 == Event[1].votes
+end
 
-    context "the JSON representation of an object" do
-      should "just be the to_hash of a model" do
-        json = JSON.parse(Programmer.create(:language => "Ruby").to_json)
+# a Model with individual attribute writing needs
+class Order < Ohm::Model
+  attribute :state
 
-        assert_equal ["id", "language"], json.keys.sort
-        assert_equal "1", json["id"]
-        assert_equal "Ruby", json["language"]
-      end
-    end
+  def authorize!
+    write_remote :state, 'authorized'
   end
+end
 
-  describe "a Model with individual attribute writing needs" do
-    class Order < Ohm::Model
-      attribute :state
-
-      def authorize!
-        write_remote :state, 'authorized'
-      end
-    end
-
-    test "writes locally" do
-      order = Order.create(:state => "pending")
-      order.authorize!
-      assert_equal 'authorized', order.state
-    end
+test "writes locally" do
+  order = Order.create(:state => "pending")
+  order.authorize!
+  assert 'authorized' == order.state
+end
 
-    test "writes remotely" do
-      order = Order.create(:state => "pending")
-      order.authorize!
-      order = Order[order.id]
-      assert_equal 'authorized', order.state
-    end
-  end
+test "writes remotely" do
+  order = Order.create(:state => "pending")
+  order.authorize!
+  order = Order[order.id]
+  assert 'authorized' == order.state
+end
 
-  context "namespaced models" do
-    should "be persisted" do
-      SomeNamespace::Foo.create(:name => "foo")
+# namespaced models
+test "be persisted" do
+  SomeNamespace::Foo.create(:name => "foo")
 
-      assert_equal "hash", Ohm.redis.type("SomeNamespace::Foo:1")
+  assert "hash" == Ohm.redis.type("SomeNamespace::Foo:1")
 
-      assert_equal "foo", SomeNamespace::Foo[1].name
-    end
-  end
+  assert "foo" == SomeNamespace::Foo[1].name
 end