ohm 0.1.0.rc5 → 0.1.0.rc6

data/test/mutex_test.rb

@@ -1,89 +1,84 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+# encoding: UTF-8
 
-class TestMutex < Test::Unit::TestCase
-  class Person < Ohm::Model
-    attribute :name
-  end
-
-  setup do
-    Ohm.flush
-    @p1 = Person.create :name => "Albert"
-    @p2 = Person[1]
-  end
+require File.expand_path("./helper", File.dirname(__FILE__))
 
-  context "Using a mutex on an object" do
-    should "prevent other instances of the same object from grabing a locked record" do
-      t1 = t2 = nil
-      p1 = Thread.new do
-        @p1.mutex do
-          sleep 0.4
-          t1 = Time.now
-        end
-      end
+class Person < Ohm::Model
+  attribute :name
+end
 
-      p2 = Thread.new do
-        sleep 0.1
-        @p2.mutex do
-          t2 = Time.now
-        end
-      end
+setup do
+  @p1 = Person.create :name => "Albert"
+  @p2 = Person[1]
+end
 
-      p1.join
-      p2.join
-      assert t2 > t1
+test "prevent other instances of the same object from grabing a locked record" do
+  t1 = t2 = nil
+  p1 = Thread.new do
+    @p1.mutex do
+      sleep 0.01
+      t1 = Time.now
     end
+  end
 
-    should "allow an instance to lock a record if the previous lock is expired" do
-      @p1.send(:lock!)
-      @p2.mutex do
-        assert true
-      end
+  p2 = Thread.new do
+    sleep 0.01
+    @p2.mutex do
+      t2 = Time.now
     end
+  end
 
-    should "work if two clients are fighting for the lock" do
-      @p1.send(:lock!)
-      @p3 = Person[1]
-      @p4 = Person[1]
+  p1.join
+  p2.join
+  assert t2 > t1
+end
 
-      assert_nothing_raised do
-        p1 = Thread.new { @p1.mutex {} }
-        p2 = Thread.new { @p2.mutex {} }
-        p3 = Thread.new { @p3.mutex {} }
-        p4 = Thread.new { @p4.mutex {} }
-        p1.join
-        p2.join
-        p3.join
-        p4.join
-      end
-    end
+test "allow an instance to lock a record if the previous lock is expired" do
+  @p1.send(:lock!)
+  @p2.mutex do
+    assert true
+  end
+end
 
-    should "yield the right result after a lock fight" do
-      class Candidate < Ohm::Model
-        attribute :name
-        counter :votes
-      end
+test "work if two clients are fighting for the lock" do
+  @p1.send(:lock!)
+  @p3 = Person[1]
+  @p4 = Person[1]
 
-      @candidate = Candidate.create :name => "Foo"
-      @candidate.send(:lock!)
+  p1 = Thread.new { @p1.mutex {} }
+  p2 = Thread.new { @p2.mutex {} }
+  p3 = Thread.new { @p3.mutex {} }
+  p4 = Thread.new { @p4.mutex {} }
+  p1.join
+  p2.join
+  p3.join
+  p4.join
+end
 
-      threads = []
+test "yield the right result after a lock fight" do
+  class Candidate < Ohm::Model
+    attribute :name
+    counter :votes
+  end
+
+  @candidate = Candidate.create :name => "Foo"
+  @candidate.send(:lock!)
 
-      n = 3
-      m = 2
+  threads = []
 
-      n.times do
-        threads << Thread.new do
-          m.times do
-            @candidate.mutex do
-              sleep 0.1
-              @candidate.incr(:votes)
-            end
-          end
+  n = 3
+  m = 2
+
+  n.times do
+    threads << Thread.new do
+      m.times do
+        @candidate.mutex do
+          sleep 0.01
+          @candidate.incr(:votes)
         end
       end
-
-      threads.each { |t| t.join }
-      assert_equal n * m, @candidate.votes
     end
   end
+
+  threads.each { |t| t.join }
+  assert n * m == @candidate.votes
 end

data/test/pattern_test.rb

@@ -1,8 +1,10 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+# encoding: UTF-8
 
-class TestArray < Test::Unit::TestCase
-  test "should provide pattern matching" do
-    assert(Ohm::Pattern[1, Fixnum] === [1, 2])
-    assert(Ohm::Pattern[String, Array] === ["foo", ["bar"]])
-  end
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+prepare.clear
+
+test "should provide pattern matching" do
+  assert(Ohm::Pattern[1, Fixnum] === [1, 2])
+  assert(Ohm::Pattern[String, Array] === ["foo", ["bar"]])
 end

data/test/upgrade_script_test.rb

@@ -1,68 +1,62 @@
 # encoding: UTF-8
 
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+require File.expand_path("./helper", File.dirname(__FILE__))
 
 require "ohm/utils/upgrade"
 
-# class User < Ohm::Model
-#   attribute :name
-#   attribute :email
-#
-#   counter :views
-#
-#   index :email
-#
-#   set :posts
-#   list :comments
-# end
-
-class UpgradeScriptTest < Test::Unit::TestCase
-  def redis
-    Ohm.redis
-  end
+def redis
+  Ohm.redis
+end
 
-  setup do
-    redis.flushdb
+setup do
+  redis.flushdb
 
-    @users = Ohm::Key.new(:User, Ohm.redis)
+  @users = Ohm::Key.new(:User, Ohm.redis)
 
-    10.times do
-      @id = redis.incr(@users[:id])
-      @user = @users[@id]
+  10.times do
+    @id = redis.incr(@users[:id])
+    @user = @users[@id]
 
-      redis.sadd @users[:all], @id
+    redis.sadd @users[:all], @id
 
-      redis.set  @user[:name], "Albert"
-      redis.set  @user[:email], "albert-#{@id}@example.com"
-      redis.incr @user[:views]
+    redis.set  @user[:name], "Albert"
+    redis.set  @user[:email], "albert-#{@id}@example.com"
+    redis.incr @user[:views]
 
-      redis.sadd @user[:posts], 1
-      redis.sadd @user[:posts], 2
+    redis.sadd @user[:posts], 1
+    redis.sadd @user[:posts], 2
 
-      redis.lpush @user[:comments], 3
-      redis.lpush @user[:comments], 4
+    redis.lpush @user[:comments], 3
+    redis.lpush @user[:comments], 4
 
-      redis.sadd @user[:_indices], @users[:email][Ohm::Model.encode "albert-#{@id}@example.com"]
-      redis.sadd @users[:email][Ohm::Model.encode "albert-#{@id}@example.com"], @id
-    end
+    redis.sadd @user[:_indices], @users[:email][Ohm::Model.encode "albert-#{@id}@example.com"]
+    redis.sadd @users[:email][Ohm::Model.encode "albert-#{@id}@example.com"], @id
   end
+end
 
-  should "upgrade to hashes" do
-    Ohm::Utils::Upgrade.new([:User]).run
+test "upgrade to hashes" do
+  require "stringio"
 
-    @user = @users[1]
+  stderr, stdout = $stderr, $stdout
 
-    assert_nil redis.get(@user[:name])
-    assert_nil redis.get(@user[:email])
-    assert_nil redis.get(@user[:views])
+  $stderr, $stdout = StringIO.new, StringIO.new
 
-    assert_equal ["1", "2"], redis.smembers(@user[:posts])
+  Ohm::Utils::Upgrade.new([:User]).run
 
-    assert_equal [@users[:email][Ohm::Model.encode "albert-1@example.com"]], redis.smembers(@user[:_indices])
-    assert_equal ["1"], redis.smembers(@users[:email][Ohm::Model.encode "albert-1@example.com"])
+  $stderr, $stdout = stderr, stdout
 
-    assert_equal "Albert", redis.hget(@user, :name)
-    assert_equal "albert-1@example.com", redis.hget(@user, :email)
-    assert_equal "1", redis.hget(@user, :views)
-  end
+  @user = @users[1]
+
+  assert redis.get(@user[:name]).nil?
+  assert redis.get(@user[:email]).nil?
+  assert redis.get(@user[:views]).nil?
+
+  assert ["1", "2"] == redis.smembers(@user[:posts])
+
+  assert [@users[:email][Ohm::Model.encode "albert-1@example.com"]] == redis.smembers(@user[:_indices])
+  assert ["1"] == redis.smembers(@users[:email][Ohm::Model.encode "albert-1@example.com"])
+
+  assert "Albert" == redis.hget(@user, :name)
+  assert "albert-1@example.com" == redis.hget(@user, :email)
+  assert "1" == redis.hget(@user, :views)
 end

data/test/validations_test.rb

@@ -1,229 +1,245 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+# encoding: UTF-8
 
-class ValidationsTest < Test::Unit::TestCase
-  class Event < Ohm::Model
-    attribute :name
-    attribute :place
-    attribute :capacity
+require File.expand_path("./helper", File.dirname(__FILE__))
 
-    index :name
-    index :place
+class Event < Ohm::Model
+  attribute :name
+  attribute :place
+  attribute :capacity
 
-    def validate
-      assert_format(:name, /^\w+$/)
-    end
+  index :name
+  index :place
+
+  def validate
+    assert_format(:name, /^\w+$/)
   end
+end
 
-  context "A new model with validations" do
-    setup do
-      @event = Event.new
-    end
+class Validatable
+  attr_accessor :name
 
-    context "That must have a present name" do
-      should "not be created if the name is never assigned" do
-        @event.create
-        assert @event.new?
-      end
+  include Ohm::Validations
+end
 
-      should "not be created if the name assigned is empty" do
-        @event.name = ""
-        @event.create
-        assert @event.new?
-      end
+# A new model with validations
+scope do
+  setup do
+    Event.new
+  end
 
-      should "be created if the name assigned is not empty" do
-        @event.name = "hello"
-        @event.create
-        assert_not_nil @event.id
-      end
+  # That must have a present name
+  scope do
+    test "not be created if the name is never assigned" do |event|
+      event.create
+      assert event.new?
+    end
 
-      context "And must have a name with only \w+" do
-        should "not be created if the name doesn't match /^\w+$/" do
-          @event.name = "hello-world"
-          @event.create
-          assert @event.new?
-        end
-      end
+    test "not be created if the name assigned is empty" do |event|
+      event.name = ""
+      event.create
+      assert event.new?
     end
 
-    context "That must have a numeric attribute :capacity" do
-      should "fail when the value is nil" do
-        def @event.validate
-          assert_numeric :capacity
-        end
+    test "be created if the name assigned is not empty" do |event|
+      event.name = "hello"
+      event.create
+      assert event.id
+    end
 
-        @event.name = "foo"
-        @event.place = "bar"
-        @event.create
+    # And must have a name with only \w+
+    scope do
+      test "not be created if the name doesn't match /^\w+$/" do |event|
+        event.name = "hello-world"
+        event.create
+        assert event.new?
+      end
+    end
+  end
 
-        assert @event.new?
-        assert_equal [[:capacity, :not_numeric]], @event.errors
+  # That must have a numeric attribute :capacity
+  scope do
+    test "fail when the value is nil" do |event|
+      def event.validate
+        assert_numeric :capacity
       end
 
-      should "fail when the value is not numeric" do
-        def @event.validate
-          assert_numeric :capacity
-        end
+      event.name = "foo"
+      event.place = "bar"
+      event.create
 
-        @event.name = "foo"
-        @event.place = "bar"
-        @event.capacity = "baz"
-        @event.create
+      assert event.new?
+      assert [[:capacity, :not_numeric]] == event.errors
+    end
 
-        assert @event.new?
-        assert_equal [[:capacity, :not_numeric]], @event.errors
+    test "fail when the value is not numeric" do |event|
+      def event.validate
+        assert_numeric :capacity
       end
 
-      should "succeed when the value is numeric" do
-        def @event.validate
-          assert_numeric :capacity
-        end
+      event.name = "foo"
+      event.place = "bar"
+      event.capacity = "baz"
+      event.create
 
-        @event.name = "foo"
-        @event.place = "bar"
-        @event.capacity = 42
-        @event.create
+      assert event.new?
+      assert [[:capacity, :not_numeric]] == event.errors
+    end
 
-        assert_not_nil @event.id
+    test "succeed when the value is numeric" do |event|
+      def event.validate
+        assert_numeric :capacity
       end
-    end
 
-    context "That must have a unique name" do
-      should "fail when the value already exists" do
-        def @event.validate
-          assert_unique :name
-        end
+      event.name = "foo"
+      event.place = "bar"
+      event.capacity = 42
+      event.create
 
-        Event.create(:name => "foo")
-        @event.name = "foo"
-        @event.create
+      assert event.id
+    end
+  end
 
-        assert @event.new?
-        assert_equal [[:name, :not_unique]], @event.errors
+  # That must have a unique name
+  scope do
+    test "fail when the value already exists" do |event|
+      def event.validate
+        assert_unique :name
       end
-    end
 
-    context "That must have a unique name scoped by place" do
-      should "fail when the value already exists for a scoped attribute" do
-        def @event.validate
-          assert_unique [:name, :place]
-        end
+      Event.create(:name => "foo")
+      event.name = "foo"
+      event.create
 
-        Event.create(:name => "foo", :place => "bar")
-        @event.name = "foo"
-        @event.place = "bar"
-        @event.create
+      assert event.new?
+      assert [[:name, :not_unique]] == event.errors
+    end
+  end
 
-        assert @event.new?
-        assert_equal [[[:name, :place], :not_unique]], @event.errors
+  # That must have a unique name scoped by place
+  scope do
+    test "fail when the value already exists for a scoped attribute" do |event|
+      def event.validate
+        assert_unique [:name, :place]
+      end
 
-        @event.place = "baz"
-        @event.create
+      Event.create(:name => "foo", :place => "bar")
+      event.name = "foo"
+      event.place = "bar"
+      event.create
 
-        assert @event.valid?
-      end
-    end
+      assert event.new?
+      assert [[[:name, :place], :not_unique]] == event.errors
 
-    context "That defines a unique validation on a non indexed attribute" do
-      should "raise ArgumentError" do
-        def @event.validate
-          assert_unique :capacity
-        end
+      event.place = "baz"
+      event.create
 
-        assert_raises(Ohm::Model::IndexNotFound) do
-          @event.valid?
-        end
-      end
+      assert event.valid?
     end
   end
 
-  context "An existing model with a valid name" do
-    setup do
-      @event = Event.create(:name => "original")
-    end
-
-    context "That has the name changed" do
-      should "not be saved if the new name is nil" do
-        @event.name = nil
-        @event.save
-        assert_equal false, @event.valid?
-        assert_equal "original", Event[@event.id].name
-      end
-
-      should "not be saved if the name assigned is empty" do
-        @event.name = ""
-        @event.save
-        assert_equal false, @event.valid?
-        assert_equal "original", Event[@event.id].name
+  # That defines a unique validation on a non indexed attribute
+  scope do
+    test "raise ArgumentError" do |event|
+      def event.validate
+        assert_unique :capacity
       end
 
-      should "be saved if the name assigned is not empty" do
-        @event.name = "hello"
-        @event.save
-        assert @event.valid?
-        assert_equal "hello", Event[@event.id].name
+      assert_raise(Ohm::Model::IndexNotFound) do
+        event.valid?
       end
     end
   end
+end
 
-  context "Validations module" do
-    class Validatable
-      attr_accessor :name
+# An existing model with a valid name
+scope do
+  setup do
+    event = Event.create(:name => "original")
+  end
 
-      include Ohm::Validations
+  # That has the name changed
+  scope do
+    test "not be saved if the new name is nil" do |event|
+      event.name = nil
+      event.save
+      assert false == event.valid?
+      assert "original" == Event[event.id].name
     end
 
-    setup do
-      @target = Validatable.new
+    test "not be saved if the name assigned is empty" do |event|
+      event.name = ""
+      event.save
+      assert false == event.valid?
+      assert "original" == Event[event.id].name
     end
 
-    context "assert" do
-      should "add errors to a collection" do
-        def @target.validate
-          assert(false, "Something bad")
-        end
+    test "be saved if the name assigned is not empty" do |event|
+      event.name = "hello"
+      event.save
+      assert event.valid?
+      assert "hello" == Event[event.id].name
+    end
+  end
+end
 
-        @target.validate
+# Validations module
+scope do
+  setup do
+    Validatable.new
+  end
 
-        assert_equal ["Something bad"], @target.errors
+  # assert
+  scope do
+    test "add errors to a collection" do |target|
+      def target.validate
+        assert(false, "Something bad")
       end
 
-      should "allow for nested validations" do
-        def @target.validate
-          if assert(true, "No error")
-            assert(false, "Chained error")
-          end
+      target.validate
 
-          if assert(false, "Parent error")
-            assert(false, "No chained error")
-          end
-        end
+      assert ["Something bad"] == target.errors
+    end
 
-        @target.validate
+    test "allow for nested validations" do |target|
+      def target.validate
+        if assert(true, "No error")
+          assert(false, "Chained error")
+        end
 
-        assert_equal ["Chained error", "Parent error"], @target.errors
+        if assert(false, "Parent error")
+          assert(false, "No chained error")
+        end
       end
+
+      target.validate
+
+      assert ["Chained error", "Parent error"] == target.errors
     end
+  end
 
-    context "assert_present" do
-      setup do
-        def @target.validate
-          assert_present(:name)
-        end
+  # assert_present
+  scope do
+    setup do
+      target = Validatable.new
+
+      def target.validate
+        assert_present(:name)
       end
 
-      should "fail when the attribute is nil" do
-        @target.validate
+      target
+    end
+
+    test "fail when the attribute is nil" do |target|
+      target.validate
 
-        assert_equal [[:name, :not_present]], @target.errors
-      end
+      assert [[:name, :not_present]] == target.errors
+    end
 
-      should "fail when the attribute is empty" do
-        @target.name = ""
-        @target.validate
+    test "fail when the attribute is empty" do |target|
+      target.name = ""
+      target.validate
 
-        assert_equal [[:name, :not_present]], @target.errors
-      end
+      assert [[:name, :not_present]] == target.errors
     end
   end
 end