ohm 0.0.38 → 0.1.0.rc1

data/README.markdown

@@ -364,3 +364,28 @@ values. The result of the block is used as the error message:
 
     error_messages
     # => ["The email foo@example.com is already registered."]
+
+Versions
+========
+
+Ohm uses features from Redis > 1.3.10. If you are stuck in previous
+versions, please use Ohm 0.0.35 instead.
+
+Upgrading from 0.0.x to 0.1
+---------------------------
+
+Since Ohm 0.1 changes the persistence strategy (from 1-key-per-attribute
+to Hashes), you'll need to run a script to upgrade your old data set.
+Fortunately, it is built in:
+
+    require "ohm/utils/upgrade"
+
+    Ohm.connect :port => 6380
+
+    Ohm::Utils::Upgrade.new([:User, :Post, :Comment]).run
+
+Yes, you need to provide the model names. The good part is that you
+don't have to load your application environment. Since we assume it's
+very likely that you have a bunch of data, the script uses
+[Batch](http://github.com/djanowski/batch) to show you some progress
+while the process runs.

data/Rakefile

@@ -24,14 +24,6 @@ task :stop do
   end
 end
 
-task :test do
-  Dir["test/**/*_test.rb"].each do |file|
-    fork do
-      load file
-    end
-
-    Process.wait
-
-    exit $?.exitstatus unless $?.success?
-  end
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
 end

data/lib/ohm.rb

@@ -9,7 +9,7 @@ require File.join(File.dirname(__FILE__), "ohm", "key")
 require File.join(File.dirname(__FILE__), "ohm", "collection")
 
 module Ohm
-  VERSION = "0.0.38"
+  VERSION = "0.1.0.rc1"
 
   # Provides access to the Redis database. This is shared accross all models and instances.
   def redis
@@ -149,10 +149,10 @@ module Ohm
       #   user.name == "A"
       #   # => true
       def sort_by(att, options = {})
-        options.merge!(:by => model.key("*", att))
+        options.merge!(:by => model.key("*->#{att}"))
 
         if options[:get]
-          raw.sort(options.merge(:get => model.key("*", options[:get])))
+          raw.sort(options.merge(:get => model.key("*->#{options[:get]}")))
         else
           sort(options)
         end
@@ -200,7 +200,7 @@ module Ohm
       Raw = Ohm::Set
 
       def inspect
-        "#<Set (#{model}): #{raw.to_a.inspect}>"
+        "#<Set (#{model}): #{all.inspect}>"
       end
 
       # Returns an intersection with the sets generated from the passed hash.
@@ -212,7 +212,7 @@ module Ohm
       #   # You can combine the result with sort and other set operations:
       #   @events.sort_by(:name)
       def find(hash)
-        apply(:sinterstore, hash, "+")
+        apply(:sinterstore, hash, :+)
       end
 
       # Returns the difference between the receiver and the passed sets.
@@ -220,15 +220,16 @@ module Ohm
       # @example
       #   @events = Event.find(public: true).except(status: "sold_out")
       def except(hash)
-        apply(:sdiffstore, hash, "-")
+        apply(:sdiffstore, hash, :-)
       end
 
     private
 
-      # Apply a redis operation on a collection of sets.
+      # Apply a Redis operation on a collection of sets.
       def apply(operation, hash, glue)
-        target = key.volatile.group(glue).append(*keys(hash))
-        model.db.send(operation, target, *target.sub_keys)
+        keys = keys(hash)
+        target = key.volatile.send(glue, Key[*keys])
+        model.db.send(operation, target, key, *keys)
         Set.new(target, Wrapper.wrap(model))
       end
 
@@ -265,7 +266,7 @@ module Ohm
       end
 
       def inspect
-        "#<List (#{model}): #{raw.to_a.inspect}>"
+        "#<List (#{model}): #{all.inspect}>"
       end
     end
 
@@ -290,7 +291,7 @@ module Ohm
       # @overload assert_unique [:street, :city]
       #   Validates that the :street and :city pair is unique.
       def assert_unique(attrs)
-        result = db.sinter(*Array(attrs).map { |att| index_key_for(att, send(att)) }) || []
+        result = db.sinter(*Array(attrs).map { |att| index_key_for(att, send(att)) })
         assert result.empty? || !new? && result.include?(id.to_s), [attrs, :not_unique]
       end
     end
@@ -490,7 +491,7 @@ module Ohm
     end
 
     def self.to_reference
-      name.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
+      name.to_s.match(/^(?:.*::)*(.*)$/)[1].gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
     end
 
     def self.attr_collection_reader(name, type, model)
@@ -602,9 +603,7 @@ module Ohm
 
     def delete
       delete_from_indices
-      delete_attributes(attributes)
-      delete_attributes(counters)
-      delete_attributes(collections)
+      delete_attributes(collections) unless collections.empty?
       delete_model_membership
       self
     end
@@ -612,17 +611,16 @@ module Ohm
     # Increment the counter denoted by :att.
     #
     # @param att [Symbol] Attribute to increment.
-    def incr(att)
+    def incr(att, count = 1)
       raise ArgumentError, "#{att.inspect} is not a counter." unless counters.include?(att)
-      write_local(att, db.incr(key(att)))
+      write_local(att, db.hincrby(key, att, count))
     end
 
     # Decrement the counter denoted by :att.
     #
     # @param att [Symbol] Attribute to decrement.
-    def decr(att)
-      raise ArgumentError, "#{att.inspect} is not a counter." unless counters.include?(att)
-      write_local(att, db.decr(key(att)))
+    def decr(att, count = 1)
+      incr(att, -count)
     end
 
     def attributes
@@ -695,26 +693,22 @@ module Ohm
       self.class.key(id, *args)
     end
 
-    # Write attributes using MSET
     def write
       unless attributes.empty?
-        rems, adds = attributes.map { |a| [key(a), send(a)] }.partition { |t| t.last.to_s.empty? }
+        attributes.each_with_index do |att, index|
+          value = send(att).to_s
 
-        db.del(*rems.flatten.compact) unless rems.empty?
-        db.mapped_mset(adds.flatten)  unless adds.empty?
+          if value.empty?
+            db.hdel(key, att)
+          else
+            db.hset(key, att, value)
+          end
+        end
       end
     end
 
     def self.const_missing(name)
-      wrapper = Wrapper.new(name) { const_get(name) }
-
-      # Allow others to hook to const_missing.
-      begin
-        super(name)
-      rescue NameError
-      end
-
-      wrapper
+      Wrapper.new(name) { const_get(name) }
     end
 
   private
@@ -745,17 +739,16 @@ module Ohm
     end
 
     def delete_attributes(atts)
-      atts.each do |att|
-        db.del(key(att))
-      end
+      db.del(*atts.map { |att| key(att) })
     end
 
     def create_model_membership
-      db.sadd(self.class.key(:all), id)
+      self.class.all << self
     end
 
     def delete_model_membership
-      db.srem(self.class.key(:all), id)
+      db.del(key)
+      self.class.all.delete(self)
     end
 
     def update_indices
@@ -786,7 +779,7 @@ module Ohm
     end
 
     def delete_from_indices
-      (db.smembers(key(:_indices)) || []).each do |index|
+      db.smembers(key(:_indices)).each do |index|
         db.srem(index, id)
       end
 
@@ -803,7 +796,7 @@ module Ohm
 
     def read_remote(att)
       unless new?
-        value = db.get(key(att))
+        value = db.hget(key, att)
         value.respond_to?(:force_encoding) ?
           value.force_encoding("UTF-8") :
           value

data/lib/ohm/collection.rb

@@ -124,7 +124,7 @@ module Ohm
 
     # @return [Array] Elements of the list.
     def all
-      db.lrange(key, 0, -1) || []
+      db.lrange(key, 0, -1)
     end
 
     # @return [Integer] Returns the number of elements in the list.
@@ -171,7 +171,7 @@ module Ohm
     end
 
     def all
-      db.smembers(key) || []
+      db.smembers(key)
     end
 
     # @return [Integer] Returns the number of elements in the set.

data/lib/ohm/key.rb

@@ -1,50 +1,28 @@
 module Ohm
 
   # Represents a key in Redis.
-  class Key
-    attr :parts
-    attr :glue
-    attr :namespace
+  class Key < String
+    Volatile = new("~")
 
-    def self.[](*parts)
-      Key.new(parts)
+    def self.[](*args)
+      new(args.join(":"))
     end
 
-    def initialize(parts, glue = ":", namespace = [])
-      @parts = parts
-      @glue = glue
-      @namespace = namespace
+    def [](key)
+      self.class[self, key]
     end
 
-    def sub_keys
-      parts.map {|k| k.glue == ":" ? k : k.volatile }
-    end
-
-    def append(*parts)
-      @parts += parts
-      self
-    end
-
-    def eql?(other)
-      to_s == other.to_s
-    end
-
-    alias == eql?
-
-    def to_s
-      (namespace + [@parts.join(glue)]).join(":")
+    def volatile
+      self.index(Volatile) == 0 ? self : Volatile[self]
     end
 
-    alias inspect to_s
-    alias to_str to_s
-
-    def volatile
-      @namespace = [:~]
-      self
+    def +(other)
+      self.class.new("#{self}+#{other}")
     end
 
-    def group(glue = self.glue)
-      Key.new([self], glue, namespace.slice!(0, namespace.size))
+    def -(other)
+      self.class.new("#{self}-#{other}")
     end
   end
+
 end

data/lib/ohm/utils/upgrade.rb

@@ -0,0 +1,53 @@
+begin
+  require "batch"
+rescue LoadError => e
+  e.message << "\nTry `gem install batch`."
+end
+
+module Ohm
+  module Utils
+    class Upgrade
+      def redis
+        Ohm.redis
+      end
+
+      attr :models
+      attr :types
+
+      def initialize(models)
+        @models = models
+        @types = Hash.new { |hash, model| hash[model] = {} }
+      end
+
+      def run
+        models.each do |model|
+          ns = Ohm::Key[model]
+
+          puts "Upgrading #{model}..."
+
+          Batch.each(redis.smembers(ns[:all])) do |id|
+            instance = ns[id]
+
+            attrs = []
+            deletes = []
+
+            redis.keys(instance["*"]).each do |key|
+              field = key[instance.size.succ..-1]
+
+              type = (types[model][field] ||= redis.type(key).to_sym)
+
+              if type == :string
+                attrs << field
+                attrs << redis.get(key)
+                deletes << key
+              end
+            end
+
+            redis.hmset(instance, *attrs)
+            redis.del(*deletes)
+          end
+        end
+      end
+    end
+  end
+end

data/test/indices_test.rb

@@ -48,7 +48,7 @@ class IndicesTest < Test::Unit::TestCase
       assert_equal "~:IndicesTest::User:email:Zm9v+IndicesTest::User:activation_code:",
         User.find(:email => "foo").find(:activation_code => "").key.to_s
 
-      assert_equal "~:~:IndicesTest::User:email:Zm9v+IndicesTest::User:activation_code:YmFy+IndicesTest::User:update:YmF6",
+      assert_equal "~:IndicesTest::User:email:Zm9v+IndicesTest::User:activation_code:YmFy+IndicesTest::User:update:YmF6",
         result = User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").key.to_s
     end
 

data/test/model_module_test.rb

@@ -0,0 +1,951 @@
+# encoding: UTF-8
+
+require File.join(File.dirname(__FILE__), "test_helper")
+require "ostruct"
+
+module Model
+  class Post < Ohm::Model
+    attribute :body
+    list :comments
+    list :related, Post
+  end
+
+  class User < Ohm::Model
+    attribute :email
+    set :posts, Post
+  end
+
+  class Person < Ohm::Model
+    attribute :name
+    index :initial
+
+    def validate
+      assert_present :name
+    end
+
+    def initial
+      name[0, 1].upcase
+    end
+  end
+
+  class Event < Ohm::Model
+    attribute :name
+    counter :votes
+    set :attendees, Person
+
+    attribute :slug
+
+    def write
+      self.slug = name.to_s.downcase
+      super
+    end
+  end
+end
+
+class ScopedModelsTest < Test::Unit::TestCase
+  setup do
+    Ohm.flush
+  end
+
+  context "An event initialized with a hash of attributes" do
+    should "assign the passed attributes" do
+      event = Model::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 = Model::Event.create(:name => "Ruby Tuesday")
+      event2 = Model::Event.create(:name => "Ruby Meetup")
+
+      assert_equal "1", event1.id
+      assert_equal "2", event2.id
+    end
+
+    should "return the unsaved object if validation fails" do
+      assert Model::Person.create(:name => nil).kind_of?(Model::Person)
+    end
+  end
+
+  context "An event updated from a hash of attributes" do
+    class ::Model::Meetup < Ohm::Model
+      attribute :name
+      attribute :location
+
+      def validate
+        assert_present :name
+      end
+    end
+
+    should "assign an id and save the object" do
+      event = Model::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 = Model::Meetup.create(:name => "Ruby Tuesday")
+      assert !event.update(:name => nil)
+    end
+
+    should "save the attributes in UTF8" do
+     event = Model::Meetup.create(:name => "32° Kisei-sen")
+     assert_equal "32° Kisei-sen", Model::Meetup[event.id].name
+    end
+
+    should "delete the attribute if set to nil" do
+      event = Model::Meetup.create(:name => "Ruby Tuesday", :location => "Los Angeles")
+      assert_equal "Los Angeles", Model::Meetup[event.id].location
+      assert event.update(:location => nil)
+      assert_equal nil, Model::Meetup[event.id].location
+    end
+
+    should "delete the attribute if set to an empty string" do
+      event = Model::Meetup.create(:name => "Ruby Tuesday", :location => "Los Angeles")
+      assert_equal "Los Angeles", Model::Meetup[event.id].location
+      assert event.update(:location => "")
+      assert_equal nil, Model::Meetup[event.id].location
+    end
+  end
+
+  context "Model definition" do
+    should "not raise if an attribute is redefined" do
+      assert_nothing_raised do
+        class ::Model::RedefinedModel < Ohm::Model
+          attribute :name
+          attribute :name
+        end
+      end
+    end
+
+    should "not raise if a counter is redefined" do
+      assert_nothing_raised do
+        class ::Model::RedefinedModel < Ohm::Model
+          counter :age
+          counter :age
+        end
+      end
+    end
+
+    should "not raise if a list is redefined" do
+      assert_nothing_raised do
+        class ::Model::RedefinedModel < Ohm::Model
+          list :todo
+          list :todo
+        end
+      end
+    end
+
+    should "not raise if a set is redefined" do
+      assert_nothing_raised do
+        class ::Model::RedefinedModel < Ohm::Model
+          set :friends
+          set :friends
+        end
+      end
+    end
+
+    should "not raise if a collection is redefined" do
+      assert_nothing_raised do
+        class ::Model::RedefinedModel < Ohm::Model
+          list :toys
+          set :toys
+        end
+      end
+    end
+
+    should "not raise if a index is redefined" do
+      assert_nothing_raised do
+        class ::Model::RedefinedModel < Ohm::Model
+          attribute :color
+          index :color
+          index :color
+        end
+      end
+    end
+  end
+
+  context "Finding an event" do
+    setup do
+      Ohm.redis.sadd("Model::Event:all", 1)
+      Ohm.redis.hset("Model::Event:1", "name", "Concert")
+    end
+
+    should "return an instance of Event" do
+      assert Model::Event[1].kind_of?(Model::Event)
+      assert_equal 1, Model::Event[1].id
+      assert_equal "Concert", Model::Event[1].name
+    end
+  end
+
+  context "Finding a user" do
+    setup do
+      Ohm.redis.sadd("Model::User:all", 1)
+      Ohm.redis.hset("Model::User:1", "email", "albert@example.com")
+    end
+
+    should "return an instance of User" do
+      assert Model::User[1].kind_of?(Model::User)
+      assert_equal 1, Model::User[1].id
+      assert_equal "albert@example.com", Model::User[1].email
+    end
+
+    should "allow to map ids to models" do
+      assert_equal [Model::User[1]], [1].map(&Model::User)
+    end
+  end
+
+  context "Updating a user" do
+    setup do
+      Ohm.redis.sadd("Model::User:all", 1)
+      Ohm.redis.set("Model::User:1:email", "albert@example.com")
+
+      @user = Model::User[1]
+    end
+
+    should "change its attributes" do
+      @user.email = "maria@example.com"
+      assert_equal "maria@example.com", @user.email
+    end
+
+    should "save the new values" do
+      @user.email = "maria@example.com"
+      @user.save
+
+      @user.email = "maria@example.com"
+      @user.save
+
+      assert_equal "maria@example.com", Model::User[1].email
+    end
+  end
+
+  context "Creating a new model" do
+    should "assign a new id to the event" do
+      event1 = Model::Event.new
+      event1.create
+
+      event2 = Model::Event.new
+      event2.create
+
+      assert !event1.new?
+      assert !event2.new?
+
+      assert_equal "1", event1.id
+      assert_equal "2", event2.id
+    end
+  end
+
+  context "Saving a model" do
+    should "create the model if it is new" do
+      event = Model::Event.new(:name => "Foo").save
+      assert_equal "Foo", Model::Event[event.id].name
+    end
+
+    should "save it only if it was previously created" do
+      event = Model::Event.new
+      event.name = "Lorem ipsum"
+      event.create
+
+      event.name = "Lorem"
+      event.save
+
+      assert_equal "Lorem", Model::Event[event.id].name
+    end
+
+    should "allow to hook into write" do
+      event = Model::Event.create(:name => "Foo")
+
+      assert_equal "foo", event.slug
+    end
+  end
+
+  context "Delete" do
+    should "delete an existing model" do
+      class ::Model::ModelToBeDeleted < Ohm::Model
+        attribute :name
+        set :foos
+        list :bars
+      end
+
+      @model = Model::ModelToBeDeleted.create(:name => "Lorem")
+
+      @model.foos << "foo"
+      @model.bars << "bar"
+
+      id = @model.id
+
+      @model.delete
+
+      assert_nil Ohm.redis.get(Model::ModelToBeDeleted.key(id))
+      assert_nil Ohm.redis.get(Model::ModelToBeDeleted.key(id, :name))
+      assert_equal Array.new, Ohm.redis.smembers(Model::ModelToBeDeleted.key(id, :foos))
+      assert_equal Array.new, Ohm.redis.lrange(Model::ModelToBeDeleted.key(id, :bars), 0, -1)
+
+      assert Model::ModelToBeDeleted.all.empty?
+    end
+
+    should "be no leftover keys" do
+      class ::Model::Foo < Ohm::Model
+        attribute :name
+        index :name
+      end
+
+      assert_equal [], Ohm.redis.keys("*")
+
+      Model::Foo.create(:name => "Bar")
+
+      assert_equal ["Model::Foo:1", "Model::Foo:1:_indices", "Model::Foo:all", "Model::Foo:id", "Model::Foo:name:QmFy"], Ohm.redis.keys("*").sort
+
+      Model::Foo[1].delete
+
+      assert_equal ["Model::Foo:id"], Ohm.redis.keys("*")
+    end
+  end
+
+  context "Listing" do
+    should "find all" do
+      event1 = Model::Event.new
+      event1.name = "Ruby Meetup"
+      event1.create
+
+      event2 = Model::Event.new
+      event2.name = "Ruby Tuesday"
+      event2.create
+
+      all = Model::Event.all
+
+      assert all.detect {|e| e.name == "Ruby Meetup" }
+      assert all.detect {|e| e.name == "Ruby Tuesday" }
+    end
+  end
+
+  context "Sorting" do
+    should "sort all" do
+      Model::Person.create :name => "D"
+      Model::Person.create :name => "C"
+      Model::Person.create :name => "B"
+      Model::Person.create :name => "A"
+
+      assert_equal %w[A B C D], Model::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 [], Model::Person.all.sort_by(:name)
+    end
+
+    should "return the first element sorted by id when using first" do
+      Model::Person.create :name => "A"
+      Model::Person.create :name => "B"
+      assert_equal "A", Model::Person.all.first.name
+    end
+
+    should "return the first element sorted by name if first receives a sorting option" do
+      Model::Person.create :name => "B"
+      Model::Person.create :name => "A"
+      assert_equal "A", Model::Person.all.first(:by => :name, :order => "ALPHA").name
+    end
+
+    should "return attribute values when the get parameter is specified" do
+      Model::Person.create :name => "B"
+      Model::Person.create :name => "A"
+
+      assert_equal "A", Model::Person.all.sort_by(:name, :get => :name, :order => "ALPHA").first
+    end
+  end
+
+  context "Loading attributes" do
+    setup do
+      event = Model::Event.new
+      event.name = "Ruby Tuesday"
+      @id = event.create.id
+    end
+
+    should "load attributes lazily" do
+      event = Model::Event[@id]
+
+      assert_nil event.send(:instance_variable_get, "@name")
+      assert_equal "Ruby Tuesday", event.name
+    end
+
+    should "load attributes as a strings" do
+      event = Model::Event.create(:name => 1)
+
+      assert_equal "1", Model::Event[event.id].name
+    end
+  end
+
+  context "Attributes of type Set" do
+    setup do
+      @person1 = Model::Person.create(:name => "Albert")
+      @person2 = Model::Person.create(:name => "Bertrand")
+      @person3 = Model::Person.create(:name => "Charles")
+
+      @event = Model::Event.new
+      @event.name = "Ruby Tuesday"
+    end
+
+    should "not be available if the model is new" do
+      assert_raise Ohm::Model::MissingID do
+        @event.attendees << Model::Person.new
+      end
+    end
+
+    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.raw.sort
+      @event.attendees.delete(@person2)
+      assert_equal ["1", "3"], Model::Event[@event.id].attendees.raw.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
+
+    should "return instances of the passed model" do
+      @event.create
+      @event.attendees << @person1
+
+      assert_equal [@person1], @event.attendees.all
+      assert_equal @person1, @event.attendees[0]
+    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
+
+    should "empty the set" do
+      @event.create
+      @event.attendees << @person1
+
+      @event.attendees.clear
+
+      assert @event.attendees.empty?
+    end
+
+    should "replace the values in the set" do
+      @event.create
+      @event.attendees << @person1
+
+      assert_equal [@person1], @event.attendees.all
+
+      @event.attendees.replace([@person2, @person3])
+
+      assert_equal [@person2, @person3], @event.attendees.sort
+    end
+
+    should "filter elements" do
+      @event.create
+      @event.attendees.add(@person1)
+      @event.attendees.add(@person2)
+
+      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
+
+  context "Attributes of type List" do
+    setup do
+      @post = Model::Post.new
+      @post.body = "Hello world!"
+      @post.create
+    end
+
+    should "return an array" do
+      assert @post.comments.all.kind_of?(Array)
+    end
+
+    should "append elements with push" do
+      @post.comments.push "1"
+      @post.comments << "2"
+
+      assert_equal ["1", "2"], @post.comments.all
+    end
+
+    should "keep the inserting order" do
+      @post.comments << "1"
+      @post.comments << "2"
+      @post.comments << "3"
+      assert_equal ["1", "2", "3"], @post.comments.all
+    end
+
+    should "keep the inserting order after saving" do
+      @post.comments << "1"
+      @post.comments << "2"
+      @post.comments << "3"
+      @post.save
+      assert_equal ["1", "2", "3"], Model::Post[@post.id].comments.all
+    end
+
+    should "respond to each" do
+      @post.comments << "1"
+      @post.comments << "2"
+      @post.comments << "3"
+
+      i = 1
+      @post.comments.each do |c|
+        assert_equal i, c.to_i
+        i += 1
+      end
+    end
+
+    should "return the size of the list" do
+      @post.comments << "1"
+      @post.comments << "2"
+      @post.comments << "3"
+      assert_equal 3, @post.comments.size
+    end
+
+    should "return the last element with pop" do
+      @post.comments << "1"
+      @post.comments << "2"
+      assert_equal "2", @post.comments.pop
+      assert_equal "1", @post.comments.pop
+      assert @post.comments.empty?
+    end
+
+    should "return the first element with shift" do
+      @post.comments << "1"
+      @post.comments << "2"
+      assert_equal "1", @post.comments.shift
+      assert_equal "2", @post.comments.shift
+      assert @post.comments.empty?
+    end
+
+    should "push to the head of the list with unshift" do
+      @post.comments.unshift "1"
+      @post.comments.unshift "2"
+      assert_equal "1", @post.comments.pop
+      assert_equal "2", @post.comments.pop
+      assert @post.comments.empty?
+    end
+
+    should "empty the list" do
+      @post.comments.unshift "1"
+      @post.comments.clear
+
+      assert @post.comments.empty?
+    end
+
+    should "replace the values in the list" do
+      @post.comments.replace(["1", "2"])
+
+      assert_equal ["1", "2"], @post.comments
+    end
+
+    should "add models" do
+      @post.related.add(Model::Post.create(:body => "Hello"))
+
+      assert_equal ["2"], @post.related.raw
+    end
+
+    should "find elements in the list" do
+      another_post = Model::Post.create
+
+      @post.related.add(another_post)
+
+      assert  @post.related.include?(another_post)
+      assert !@post.related.include?(Model::Post.create)
+    end
+
+    should "unshift models" do
+      @post.related.unshift(Model::Post.create(:body => "Hello"))
+      @post.related.unshift(Model::Post.create(:body => "Goodbye"))
+
+      assert_equal ["3", "2"], @post.related.raw
+
+      assert_equal "3", @post.related.shift.id
+
+      assert_equal "2", @post.related.pop.id
+
+      assert_nil @post.related.pop
+    end
+  end
+
+  context "Applying arbitrary transformations" do
+    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 ::Model::Appointment < Ohm::Model
+    end
+
+    class ::Model::Calendar < Ohm::Model
+      list :holidays, lambda { |v| Date.parse(v) }
+      list :subscribers, lambda { |id| MyActiveRecordModel.find(id) }
+      list :appointments, ::Model::Appointment
+    end
+
+    class ::Model::Appointment
+      attribute :text
+      reference :subscriber, lambda { |id| MyActiveRecordModel.find(id) }
+    end
+
+    setup do
+      @calendar = Model::Calendar.create
+
+      @calendar.holidays.raw << "2009-05-25"
+      @calendar.holidays.raw << "2009-07-09"
+
+      @calendar.subscribers << MyActiveRecordModel.find(1)
+    end
+
+    should "apply a transformation" do
+      assert_equal [Date.new(2009, 5, 25), Date.new(2009, 7, 9)], @calendar.holidays.all
+
+      assert_equal ["1"], @calendar.subscribers.raw.all
+      assert_equal [MyActiveRecordModel.find(1)], @calendar.subscribers.all
+    end
+
+    should "allow lambdas in references" do
+      appointment = Model::Appointment.create(:subscriber => MyActiveRecordModel.find(1))
+      assert_equal MyActiveRecordModel.find(1), appointment.subscriber
+    end
+
+    should "work with models too" do
+      @calendar.appointments.add(Model::Appointment.create(:text => "Meet with Bertrand"))
+
+      assert_equal [Model::Appointment[1]], Model::Calendar[1].appointments.sort
+    end
+  end
+
+  context "Sorting lists and sets" do
+    setup do
+      @post = Model::Post.create(:body => "Lorem")
+      @post.comments << 2
+      @post.comments << 3
+      @post.comments << 1
+    end
+
+    should "sort values" do
+      assert_equal %w{1 2 3}, @post.comments.sort
+    end
+  end
+
+  context "Sorting lists and sets by model attributes" do
+    setup do
+      @event = Model::Event.create(:name => "Ruby Tuesday")
+      @event.attendees << Model::Person.create(:name => "D")
+      @event.attendees << Model::Person.create(:name => "C")
+      @event.attendees << Model::Person.create(:name => "B")
+      @event.attendees << Model::Person.create(:name => "A")
+    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
+
+    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
+
+    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
+
+  context "Collections initialized with a Model parameter" do
+    setup do
+      @user = Model::User.create(:email => "albert@example.com")
+      @user.posts.add Model::Post.create(:body => "D")
+      @user.posts.add Model::Post.create(:body => "C")
+      @user.posts.add Model::Post.create(:body => "B")
+      @user.posts.add Model::Post.create(:body => "A")
+    end
+
+    should "return instances of the passed model" do
+      assert_equal Model::Post, @user.posts.first.class
+    end
+  end
+
+  context "Counters" do
+    setup do
+      @event = Model::Event.create(:name => "Ruby Tuesday")
+    end
+
+    should "raise ArgumentError if the attribute is not a counter" do
+      assert_raise ArgumentError do
+        @event.incr(:name)
+      end
+    end
+
+    should "be zero if not initialized" do
+      assert_equal 0, @event.votes
+    end
+
+    should "be able to increment a counter" do
+      @event.incr(:votes)
+      assert_equal 1, @event.votes
+    end
+
+    should "be able to decrement a counter" do
+      @event.decr(:votes)
+      assert_equal -1, @event.votes
+    end
+  end
+
+  context "Comparison" do
+    setup do
+      @user = Model::User.create(:email => "foo")
+    end
+
+    should "be comparable to other instances" do
+      assert_equal @user, Model::User[@user.id]
+
+      assert_not_equal @user, Model::User.create
+      assert_not_equal Model::User.new, Model::User.new
+    end
+
+    should "not be comparable to instances of other models" do
+      assert_not_equal @user, Model::Event.create(:name => "Ruby Tuesday")
+    end
+
+    should "be comparable to non-models" do
+      assert_not_equal @user, 1
+      assert_not_equal @user, true
+
+      # Not equal although the other object responds to #key.
+      assert_not_equal @user, OpenStruct.new(:key => @user.send(:key))
+    end
+  end
+
+  context "Debugging" do
+    class ::Model::Bar < Ohm::Model
+      attribute :name
+      counter :visits
+      set :friends
+      list :comments
+
+      def foo
+        bar.foo
+      end
+
+      def baz
+        bar.new.foo
+      end
+
+      def bar
+        SomeMissingConstant
+      end
+    end
+
+    should "provide a meaningful inspect" do
+      bar = Model::Bar.new
+
+      assert_equal "#<Model::Bar:? name=nil friends=nil comments=nil visits=0>", bar.inspect
+
+      bar.update(:name => "Albert")
+      bar.friends << 1
+      bar.friends << 2
+      bar.comments << "A"
+      bar.incr(:visits)
+
+      assert_equal %Q{#<Model::Bar:#{bar.id} name="Albert" friends=#<Set: ["1", "2"]> comments=#<List: ["A"]> visits=1>}, Model::Bar[bar.id].inspect
+    end
+
+    def assert_wrapper_exception(&block)
+      begin
+        block.call
+      rescue NoMethodError => exception_raised
+      end
+
+      assert_match /You tried to call SomeMissingConstant#\w+, but SomeMissingConstant is not defined on #{__FILE__}:\d+:in `bar'/, exception_raised.message
+    end
+
+    should "inform about a miscatch by Wrapper when calling class methods" do
+      assert_wrapper_exception { Model::Bar.new.baz }
+    end
+
+    should "inform about a miscatch by Wrapper when calling instance methods" do
+      assert_wrapper_exception { Model::Bar.new.foo }
+    end
+  end
+
+  context "Overwriting write" do
+    class ::Model::Baz < Ohm::Model
+      attribute :name
+
+      def write
+        self.name = "Foobar"
+        super
+      end
+    end
+
+    should "work properly" do
+      baz = Model::Baz.new
+      baz.name = "Foo"
+      baz.save
+      baz.name = "Foo"
+      baz.save
+      assert_equal "Foobar", Model::Baz[baz.id].name
+    end
+  end
+
+  context "References to other objects" do
+    class ::Model::Comment < Ohm::Model
+    end
+
+    class ::Model::Rating < Ohm::Model
+    end
+
+    class ::Model::Note < Ohm::Model
+      attribute :content
+      reference :source, Model::Post
+      collection :comments, Model::Comment
+      list :ratings, Model::Rating
+    end
+
+    class ::Model::Comment
+      reference :note, Model::Note
+    end
+
+    class ::Model::Rating
+      attribute :value
+    end
+
+    class ::Model::Editor < Ohm::Model
+      attribute :name
+      reference :post, Model::Post
+    end
+
+    class ::Model::Post < Ohm::Model
+      reference :author, Model::Person
+      collection :notes, Model::Note, :source
+      collection :editors, Model::Editor
+    end
+
+    setup do
+      @post = Model::Post.create
+    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 = Model::Person.create(:name => "Albert").id
+        @post.save
+        assert_equal "Albert", Model::Post[@post.id].author.name
+      end
+
+      should "assign author_id if author is sent a valid instance" do
+        @post.author = Model::Person.create(:name => "Albert")
+        @post.save
+        assert_equal "Albert", Model::Post[@post.id].author.name
+      end
+
+      should "assign nil if nil is passed to author" do
+        @post.author = nil
+        @post.save
+        assert_nil Model::Post[@post.id].author
+      end
+
+      should "be cached in an instance variable" do
+        @author = Model::Person.create(:name => "Albert")
+        @post.update(:author => @author)
+
+        assert_equal @author, @post.author
+        assert @post.author.object_id == @post.author.object_id
+
+        @post.update(:author => Model::Person.create(:name => "Bertrand"))
+
+        assert_equal "Bertrand", @post.author.name
+        assert @post.author.object_id == @post.author.object_id
+
+        @post.update(:author_id => Model::Person.create(:name => "Charles").id)
+
+        assert_equal "Charles", @post.author.name
+      end
+    end
+
+    context "a collection of other objects" do
+      setup do
+        @note = Model::Note.create(:content => "Interesting stuff", :source => @post)
+        @comment = Model::Comment.create(:note => @note)
+      end
+
+      should "return a set of notes" do
+        assert_equal @note.source, @post
+        assert_equal @note, @post.notes.first
+      end
+
+      should "return a set of comments" do
+        assert_equal @comment, @note.comments.first
+      end
+
+      should "return a list of ratings" do
+        @rating = Model::Rating.create(:value => 5)
+        @note.ratings << @rating
+
+        assert_equal @rating, @note.ratings.first
+      end
+
+      should "default to the current class name" do
+        @editor = Model::Editor.create(:name => "Albert", :post => @post)
+
+        assert_equal @editor, @post.editors.first
+      end
+    end
+  end
+
+  context "Models connected to different databases" do
+    class ::Model::Car < Ohm::Model
+      attribute :name
+    end
+
+    class ::Model::Make < Ohm::Model
+      attribute :name
+    end
+
+    setup do
+      Model::Car.connect(:port => 6379, :db => 14)
+    end
+
+    teardown do
+      Model::Car.db.flushdb
+    end
+
+    should "save to the selected database" do
+      car = Model::Car.create(:name => "Twingo")
+      make = Model::Make.create(:name => "Renault")
+
+      assert_equal ["1"], Redis.new(:db => 15).smembers("Model::Make:all")
+      assert_equal [], Redis.new(:db => 15).smembers("Model::Car:all")
+
+      assert_equal ["1"], Redis.new(:db => 14).smembers("Model::Car:all")
+      assert_equal [], Redis.new(:db => 14).smembers("Model::Make:all")
+
+      assert_equal car, Model::Car[1]
+      assert_equal make, Model::Make[1]
+
+      Model::Make.db.flushdb
+
+      assert_equal car, Model::Car[1]
+      assert_nil Model::Make[1]
+    end
+  end
+end