ohm 0.1.0.rc5 → 0.1.0.rc6

data/test/connection_test.rb

@@ -1,33 +1,45 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+# encoding: UTF-8
 
-class ConnectionTest < Test::Unit::TestCase
-  test "connects lazily" do
-    assert_nothing_raised do
-      Ohm.connect(:port => 9876)
-    end
+require File.expand_path("./helper", File.dirname(__FILE__))
 
-    assert_raises(Errno::ECONNREFUSED) do
-      Ohm.redis.get "foo"
-    end
+prepare.clear
+
+test "connects lazily" do
+  Ohm.connect(:port => 9876)
+
+  begin
+    Ohm.redis.get "foo"
+  rescue => e
+    assert Errno::ECONNREFUSED == e.class
   end
+end
+
+test "provides a separate connection for each thread" do
+  assert Ohm.redis == Ohm.redis
 
-  test "provides a separate connection for each thread" do
-    assert Ohm.redis == Ohm.redis
+  conn1, conn2 = nil
 
-    conn1, conn2 = nil
+  threads = []
 
-    threads = []
+  threads << Thread.new do
+    conn1 = Ohm.redis
+  end
+
+  threads << Thread.new do
+    conn2 = Ohm.redis
+  end
 
-    threads << Thread.new do
-      conn1 = Ohm.redis
-    end
+  threads.each { |t| t.join }
 
-    threads << Thread.new do
-      conn2 = Ohm.redis
-    end
+  assert conn1 != conn2
+end
 
-    threads.each { |t| t.join }
+test "supports connecting by URL" do
+  Ohm.connect(:url => "redis://localhost:9876")
 
-    assert(conn1 != conn2)
+  begin
+    Ohm.redis.get "foo"
+  rescue => e
+    assert Errno::ECONNREFUSED == e.class
   end
 end

data/test/errors_test.rb

@@ -1,120 +1,120 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+# encoding: UTF-8
 
-class ErrorsTest < Test::Unit::TestCase
-  class User < Ohm::Model
-    attribute :name
-    attribute :account
+require File.expand_path("./helper", File.dirname(__FILE__))
 
-    def validate
-      assert_present :name
-      assert_present :account
-      assert false, :terrible_error
-    end
-  end
+class User < Ohm::Model
+  attribute :name
+  attribute :account
 
-  setup do
-    @model = User.new(:account => "")
-    @model.valid?
+  def validate
+    assert_present :name
+    assert_present :account
+    assert false, :terrible_error
   end
+end
+
+setup do
+  @model = User.new(:account => "")
+  @model.valid?
+end
 
-  context "errors handler" do
-    should "raise an error if the errors are not handled" do
-      assert_raise Ohm::Validations::Presenter::UnhandledErrors do
-        @model.errors.present do |e|
-          e.on :terrible_error do
-          end
-        end
+test "raise an error if the errors are not handled" do
+  begin
+    @model.errors.present do |e|
+      e.on :terrible_error do
       end
     end
+  rescue => e
+    assert e.class == Ohm::Validations::Presenter::UnhandledErrors
+  end
+end
 
-    should "evaluate blocks when errors match" do
-      values = []
-
-      @model.errors.present do |e|
-        e.on [:name, :not_present] do
-          values << 1
-        end
+test "evaluate blocks when errors match" do
+  values = []
 
-        e.on [:account, :not_present] do
-          values << 2
-        end
+  @model.errors.present do |e|
+    e.on [:name, :not_present] do
+      values << 1
+    end
 
-        e.on :terrible_error do
-          values << 3
-        end
-      end
+    e.on [:account, :not_present] do
+      values << 2
+    end
 
-      assert_equal [1, 2, 3], values
+    e.on :terrible_error do
+      values << 3
     end
+  end
 
-    should "accept case-like matches for an error" do
-      values = []
+  assert [1, 2, 3] == values
+end
 
-      @model.errors.present do |e|
-        e.on Array do
-          values << 1
-        end
+test "accept case-like matches for an error" do
+  values = []
 
-        e.on :terrible_error do
-          values << 3
-        end
-      end
+  @model.errors.present do |e|
+    e.on Array do
+      values << 1
+    end
 
-      assert_equal [1, 3], values
+    e.on :terrible_error do
+      values << 3
     end
+  end
 
-    should "accept multiple matches for an error" do
-      values = @model.errors.present do |e|
-        e.on [:name, :not_present], "A"
-        e.on [:account, :not_present] do
-          "B"
-        end
-        e.on :terrible_error, "C"
-      end
+  assert [1, 3] == values
+end
 
-      assert_equal %w{A B C}, values
+test "accept multiple matches for an error" do
+  values = @model.errors.present do |e|
+    e.on [:name, :not_present], "A"
+    e.on [:account, :not_present] do
+      "B"
     end
+    e.on :terrible_error, "C"
+  end
 
-    class MyPresenter < Ohm::Validations::Presenter
-      def on(*args)
-        super(*args) do
-          yield.downcase
-        end
-      end
+  assert %w{A B C} == values
+end
+
+class MyPresenter < Ohm::Validations::Presenter
+  def on(*args)
+    super(*args) do
+      yield.downcase
     end
+  end
+end
 
-    should "take a custom presenter" do
-      values = @model.errors.present(MyPresenter) do |e|
-        e.on([:name, :not_present]) { "A" }
-        e.on([:account, :not_present]) { "B" }
-        e.on(:terrible_error) { "C" }
-      end
+test "take a custom presenter" do
+  values = @model.errors.present(MyPresenter) do |e|
+    e.on([:name, :not_present]) { "A" }
+    e.on([:account, :not_present]) { "B" }
+    e.on(:terrible_error) { "C" }
+  end
 
-      assert_equal %w{a b c}, values
-    end
+  assert %w{a b c} == values
+end
 
-    should "raise an error if neither a message nor a block are supplied" do
-      assert_raise ArgumentError do
-        Ohm::Validations::Presenter.new([:custom]).present do |e|
-          e.on(:custom)
-        end
-      end
+test "raise an error if neither a message nor a block are supplied" do
+  begin
+    Ohm::Validations::Presenter.new([:custom]).present do |e|
+      e.on(:custom)
     end
+  rescue => e
+    assert e.class == ArgumentError
+  end
+end
 
-    should "not raise an error if the message passed is nil" do
-      values = Ohm::Validations::Presenter.new([:custom]).present do |e|
-        e.on(:custom, nil)
-      end
+test "not raise an error if the message passed is nil" do
+  values = Ohm::Validations::Presenter.new([:custom]).present do |e|
+    e.on(:custom, nil)
+  end
 
-      assert_equal [nil], values
+  assert [nil] == values
 
-      assert_nothing_raised do
-        Ohm::Validations::Presenter.new([:custom]).present do |e|
-          e.on(:custom, nil) do
-            raise "Should not call block"
-          end
-        end
-      end
+  Ohm::Validations::Presenter.new([:custom]).present do |e|
+    e.on(:custom, nil) do
+      raise "Should not call block"
     end
   end
 end

data/test/hash_key_test.rb

@@ -1,36 +1,29 @@
 # encoding: UTF-8
 
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+require File.expand_path("./helper", File.dirname(__FILE__))
 
 class Tag < Ohm::Model
   attribute :name
 end
 
-class HashKeyTest < Test::Unit::TestCase
-  setup do
-    Ohm.flush
-  end
+test "using a new record as a hash key" do
+  tag = Tag.new
+  hash = { tag => "Ruby" }
 
-  test "using a new record as a hash key" do
-    tag = Tag.new
-    hash = { tag => "Ruby" }
-
-    assert_equal "Ruby", hash[tag]
-    assert_nil hash[Tag.new]
-  end
+  assert "Ruby" == hash[tag]
+  assert hash[Tag.new].nil?
+end
 
-  test "on a persisted model" do
-    tag = Tag.create(:name => "Ruby")
+test "on a persisted model" do
+  tag = Tag.create(:name => "Ruby")
 
-    assert_equal "Ruby", { tag => "Ruby" }[tag]
-  end
+  assert "Ruby" == { tag => "Ruby" }[tag]
+end
 
-  test "on a reloaded model" do
-    tag = Tag.create(:name => "Ruby")
-    hash = { tag => "Ruby" }
+test "on a reloaded model" do
+  tag = Tag.create(:name => "Ruby")
+  hash = { tag => "Ruby" }
 
-    tag = Tag[tag.id]
-    assert_equal "Ruby", hash[tag]
-  end
+  tag = Tag[tag.id]
+  assert "Ruby" == hash[tag]
 end
-

data/test/helper.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+
+begin
+  require "ruby-debug"
+rescue LoadError
+end
+
+require "cutest"
+
+def silence_warnings
+  original_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = original_verbose
+end
+
+$VERBOSE = true
+
+require "ohm"
+
+prepare do
+  Ohm.flush
+end

data/test/indices_test.rb

@@ -1,219 +1,213 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+# encoding: UTF-8
 
-class IndicesTest < Test::Unit::TestCase
-  setup do
-    Ohm.flush
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+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 email_provider
+    email.split("@").last
   end
 
-  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 email_provider
-      email.split("@").last
-    end
-
-    def working_days
-      @working_days ||= []
-    end
-
-    def write
-      self.activation_code ||= "user:#{id}"
-      super
-    end
+  def working_days
+    @working_days ||= []
   end
 
-  context "A model with an indexed attribute" do
-    setup do
-      @user1 = User.create(:email => "foo", :activation_code => "bar", :update => "baz")
-      @user2 = User.create(:email => "bar")
-      @user3 = User.create(:email => "baz qux")
-    end
+  def write
+    self.activation_code ||= "user:#{id}"
+    super
+  end
+end
 
-    should "be able to find by the given attribute" do
-      assert_equal @user1, User.find(:email => "foo").first
-    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
 
-    should "raise an error if the parameter supplied is not a hash" do
-      assert_raises ArgumentError, "You need to supply a hash with filters. If you want to find by ID, use IndicesTest::User[id] instead." do
-        User.find(1)
-      end
-    end
+test "be able to find by the given attribute" do
+  assert @user1 == User.find(:email => "foo").first
+end
 
-    should "avoid intersections with the all collection" do
-      assert_equal "IndicesTest::User:email:#{Ohm::Model.encode "foo"}", User.find(:email => "foo").key.to_s
+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
 
-      assert_equal "~:IndicesTest::User:email:Zm9v+IndicesTest::User:activation_code:",
-        User.find(:email => "foo").find(:activation_code => "").key.to_s
+test "avoid intersections with the all collection" do
+  assert "User:email:#{Ohm::Model.encode "foo"}" == User.find(:email => "foo").key.to_s
 
-      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
+  assert "~:User:email:Zm9v+User:activation_code:" ==
+    User.find(:email => "foo").find(:activation_code => "").key.to_s
 
-    should "use a special namespace for set operations" do
-      assert_match(/^~:/, User.find(:email => "foo", :activation_code => "bar").key.to_s)
+  assert "~:User:email:Zm9v+User:activation_code:YmFy+User:update:YmF6" ==
+    result = User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").key.to_s
+end
 
-      assert Ohm.redis.keys("~:*").size > 0
-    end
+test "use a special namespace for set operations" do
+  assert User.find(:email => "foo", :activation_code => "bar").key.to_s.match(/^~:/)
 
-    should "allow multiple chained finds" do
-      assert_equal 1, User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").size
-    end
+  assert Ohm.redis.keys("~:*").size > 0
+end
 
-    should "raise if the field is not indexed" do
-      assert_raises(Ohm::Model::IndexNotFound) do
-        User.find(:sandunga => "foo")
-      end
-    end
+test "allow multiple chained finds" do
+  assert 1 == User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").size
+end
 
-    should "return nil if no results are found" do
-      assert User.find(:email => "foobar").empty?
-      assert_equal nil, User.find(:email => "foobar").first
-    end
+test "raise if the field is not indexed" do
+  assert_raise(Ohm::Model::IndexNotFound) do
+    User.find(:sandunga => "foo")
+  end
+end
 
-    should "update indices when changing attribute values" do
-      @user1.email = "baz"
-      @user1.save
+test "return nil if no results are found" do
+  assert User.find(:email => "foobar").empty?
+  assert nil == User.find(:email => "foobar").first
+end
 
-      assert_equal [], User.find(:email => "foo").all
-      assert_equal [@user1], User.find(:email => "baz").all
-    end
+test "update indices when changing attribute values" do
+  @user1.email = "baz"
+  @user1.save
 
-    should "remove from the index after deleting" do
-      @user2.delete
+  assert [] == User.find(:email => "foo").all
+  assert [@user1] == User.find(:email => "baz").all
+end
 
-      assert_equal [], User.find(:email => "bar").all
-    end
+test "remove from the index after deleting" do
+  @user2.delete
 
-    should "work with attributes that contain spaces" do
-      assert_equal [@user3], User.find(:email => "baz qux").all
-    end
-  end
+  assert [] == User.find(:email => "bar").all
+end
 
-  context "Indexing arbitrary attributes" do
-    setup do
-      @user1 = User.create(:email => "foo@gmail.com")
-      @user2 = User.create(:email => "bar@gmail.com")
-      @user3 = User.create(:email => "bazqux@yahoo.com")
-    end
-
-    should "allow indexing by an arbitrary attribute" do
-      assert_equal [@user1, @user2], User.find(:email_provider => "gmail.com").to_a.sort_by { |u| u.id }
-      assert_equal [@user3], User.find(:email_provider => "yahoo.com").all
-    end
-
-    should "allow indexing by an attribute that is lazily set" do
-      assert_equal [@user1], User.find(:activation_code => "user:1").to_a
-    end
-  end
+test "work with attributes that contain spaces" do
+  assert [@user3] == User.find(:email => "baz qux").all
+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
 
-  context "Indexing enumerables" do
-    setup do
-      @user1 = User.create(:email => "foo@gmail.com")
-      @user2 = User.create(:email => "bar@gmail.com")
-
-      @user1.working_days << "Mon"
-      @user1.working_days << "Tue"
-      @user2.working_days << "Mon"
-      @user2.working_days << "Wed"
-
-      @user1.save
-      @user2.save
-    end
-
-    should "index each item" do
-      assert_equal [@user1, @user2], User.find(:working_days => "Mon").to_a.sort_by { |u| u.id }
-    end
-
-    # TODO If we deal with Ohm collections, the updates are atomic but the reindexing never happens.
-    # One solution may be to reindex after inserts or deletes in collection.
-    should "remove the indices when the object changes" do
-      @user2.working_days.delete "Mon"
-      @user2.save
-      assert_equal [@user1], User.find(:working_days => "Mon").all
-    end
+test "allow indexing by an arbitrary attribute" do
+  assert [@user1, @user2] == User.find(:email_provider => "gmail.com").to_a.sort_by { |u| u.id }
+  assert [@user3] == User.find(:email_provider => "yahoo.com").all
+end
+
+test "allow indexing by an attribute that is lazily set" do
+  assert [@user1] == User.find(:activation_code => "user:1").to_a
+end
+
+# Indexing enumerables
+setup do
+  @user1 = User.create(:email => "foo@gmail.com")
+  @user2 = User.create(:email => "bar@gmail.com")
+
+  @user1.working_days << "Mon"
+  @user1.working_days << "Tue"
+  @user2.working_days << "Mon"
+  @user2.working_days << "Wed"
+
+  @user1.save
+  @user2.save
+end
+
+test "index each item" do
+  assert [@user1, @user2] == User.find(:working_days => "Mon").to_a.sort_by { |u| u.id }
+end
+
+# TODO If we deal with Ohm collections, the updates are atomic but the reindexing never happens.
+# One solution may be to reindex after inserts or deletes in collection.
+test "remove the indices when the object changes" do
+  @user2.working_days.delete "Mon"
+  @user2.save
+  assert [@user1] == User.find(:working_days => "Mon").all
+end
+
+# Intersection and difference
+class Event < Ohm::Model
+  attr_writer :days
+
+  attribute :timeline
+  index :timeline
+  index :days
+
+  def days
+    @days ||= []
   end
+end
 
-  context "Intersection and difference" do
-    class Event < Ohm::Model
-      attr_writer :days
-
-      attribute :timeline
-      index :timeline
-      index :days
-
-      def days
-        @days ||= []
-      end
-    end
-
-    setup do
-      @event1 = Event.create(:timeline => 1).update(:days => [1, 2])
-      @event2 = Event.create(:timeline => 1).update(:days => [2, 3])
-      @event3 = Event.create(:timeline => 2).update(:days => [3, 4])
-      @event4 = Event.create(:timeline => 2).update(:days => [1, 3])
-    end
-
-    should "intersect multiple sets of results" do
-      assert_equal [@event1], Event.find(:days => [1, 2]).all
-      assert_equal [@event1], Event.find(:timeline => 1, :days => [1, 2]).all
-      assert_equal [@event1], Event.find(:timeline => 1).find(:days => [1, 2]).all
-    end
-
-    should "compute the difference between sets" do
-      assert_equal [@event2], Event.find(:timeline => 1).except(:days => 1).all
-    end
-
-    should "raise if the argument is not an index" do
-      assert_raises(Ohm::Model::IndexNotFound) do
-        Event.find(:timeline => 1).except(:not_an_index => 1)
-      end
-    end
-
-    should "work with strings that generate a new line when encoded" do
-      user = User.create(:email => "foo@bar", :update => "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan")
-      assert_equal [user], User.find(:update => "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan").all
-    end
+setup do
+  @event1 = Event.create(:timeline => 1).update(:days => [1, 2])
+  @event2 = Event.create(:timeline => 1).update(:days => [2, 3])
+  @event3 = Event.create(:timeline => 2).update(:days => [3, 4])
+  @event4 = Event.create(:timeline => 2).update(:days => [1, 3])
+end
+
+test "intersect multiple sets of results" do
+  assert [@event1] == Event.find(:days => [1, 2]).all
+  assert [@event1] == Event.find(:timeline => 1, :days => [1, 2]).all
+  assert [@event1] == Event.find(:timeline => 1).find(:days => [1, 2]).all
+end
+
+test "compute the difference between sets" do
+  assert [@event2] == Event.find(:timeline => 1).except(:days => 1).all
+end
+
+test "raise if the argument is not an index" do
+  assert_raise(Ohm::Model::IndexNotFound) do
+    Event.find(:timeline => 1).except(:not_an_index => 1)
   end
+end
+
+test "work with strings that generate a new line when encoded" do
+  user = User.create(:email => "foo@bar", :update => "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan")
+  assert [user] == User.find(:update => "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan").all
+end
 
-  context "New indices" do
-    should "populate a new index when the model is saved" do
-      class Event < Ohm::Model
-        attribute :name
-      end
+# New indices
+test "populate a new index when the model is saved" do
+  class Event < Ohm::Model
+    attribute :name
+  end
 
-      foo = Event.create(:name => "Foo")
+  foo = Event.create(:name => "Foo")
 
-      assert_raise(Ohm::Model::IndexNotFound) { Event.find(:name => "Foo") }
+  assert_raise(Ohm::Model::IndexNotFound) { Event.find(:name => "Foo") }
 
-      class Event < Ohm::Model
-        index :name
-      end
+  class Event < Ohm::Model
+    index :name
+  end
 
-      # Find works correctly once the index is added.
-      assert_nothing_raised { Event.find(:name => "Foo") }
+  # Find works correctly once the index is added.
+  Event.find(:name => "Foo")
 
-      # The index was added after foo was created.
-      assert Event.find(:name => "Foo").empty?
+  # The index was added after foo was created.
+  assert Event.find(:name => "Foo").empty?
 
-      bar = Event.create(:name => "Bar")
+  bar = Event.create(:name => "Bar")
 
-      # Bar was indexed properly.
-      assert_equal bar, Event.find(:name => "Bar").first
+  # Bar was indexed properly.
+  assert bar == Event.find(:name => "Bar").first
 
-      # Saving all the objects populates the indices.
-      Event.all.each { |e| e.save }
+  # Saving all the objects populates the indices.
+  Event.all.each { |e| e.save }
 
-      # Now foo is indexed.
-      assert_equal foo, Event.find(:name => "Foo").first
-    end
-  end
+  # Now foo is indexed.
+  assert foo == Event.find(:name => "Foo").first
 end