ohm 0.1.5 → 1.0.0.alpha1

data/lib/ohm/version.rb

@@ -1,5 +0,0 @@
-# encoding: UTF-8
-
-module Ohm
-  VERSION = "0.1.5"
-end

data/test/connection_test.rb

@@ -1,101 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-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
-
-  conn1, conn2 = nil
-
-  threads = []
-
-  threads << Thread.new do
-    conn1 = Ohm.redis
-  end
-
-  threads << Thread.new do
-    conn2 = Ohm.redis
-  end
-
-  threads.each { |t| t.join }
-
-  assert conn1 != conn2
-end
-
-test "supports connecting by URL" do
-  Ohm.connect(:url => "redis://localhost:9876")
-
-  begin
-    Ohm.redis.get "foo"
-  rescue => e
-    assert Errno::ECONNREFUSED == e.class
-  end
-end
-
-test "Model.db is the same as Ohm.redis by default" do
-  class U < Ohm::Model
-  end
-
-  assert_equal U.db.object_id, Ohm.redis.object_id
-end
-
-test "provides a unique Model.db connection in one thread" do
-  class U < Ohm::Model
-  end
-
-  U.connect(db: 9876)
-
-  r1 = U.db
-  r2 = U.db
-
-  assert_equal r1.object_id, r2.object_id
-end
-
-test "provides distinct Model.db connections per thread" do
-  class U < Ohm::Model
-  end
-
-  U.connect(db: 9876)
-
-  r1 = nil
-  r2 = nil
-
-  Thread.new { r1 = U.db }.join
-  Thread.new { r2 = U.db }.join
-
-  assert r1.object_id != r2.object_id
-end
-
-test "busts threaded cache when doing Model.connect" do
-  class U < Ohm::Model
-  end
-
-  U.connect(db: 9876)
-  r1 = U.db
-
-  U.connect(db: 9876)
-  r2 = U.db
-
-  assert r1.object_id != r2.object_id
-end
-
-test "disallows the non-thread safe writing of Model.db" do
-  class U < Ohm::Model
-  end
-
-  assert_raise NoMethodError do
-    U.db = Redis.connect
-  end
-end

data/test/errors_test.rb

@@ -1,120 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class User < Ohm::Model
-  attribute :name
-  attribute :account
-
-  def validate
-    assert_present :name
-    assert_present :account
-    assert false, :terrible_error
-  end
-end
-
-setup do
-  @model = User.new(:account => "")
-  @model.valid?
-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
-
-test "evaluate blocks when errors match" do
-  values = []
-
-  @model.errors.present do |e|
-    e.on [:name, :not_present] do
-      values << 1
-    end
-
-    e.on [:account, :not_present] do
-      values << 2
-    end
-
-    e.on :terrible_error do
-      values << 3
-    end
-  end
-
-  assert [1, 2, 3] == values
-end
-
-test "accept case-like matches for an error" do
-  values = []
-
-  @model.errors.present do |e|
-    e.on Array do
-      values << 1
-    end
-
-    e.on :terrible_error do
-      values << 3
-    end
-  end
-
-  assert [1, 3] == values
-end
-
-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
-
-  assert %w{A B C} == values
-end
-
-class MyPresenter < Ohm::Validations::Presenter
-  def on(*args)
-    super(*args) do
-      yield.downcase
-    end
-  end
-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 %w{a b c} == values
-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
-
-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 [nil] == values
-
-  Ohm::Validations::Presenter.new([:custom]).present do |e|
-    e.on(:custom, nil) do
-      raise "Should not call block"
-    end
-  end
-end

data/test/indices_test.rb

@@ -1,213 +0,0 @@
-# encoding: UTF-8
-
-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
-
-  def working_days
-    @working_days ||= []
-  end
-
-  def write
-    self.activation_code ||= "user:#{id}"
-    super
-  end
-end
-
-setup do
-  @user1 = User.create(:email => "foo", :activation_code => "bar", :update => "baz")
-  @user2 = User.create(:email => "bar")
-  @user3 = User.create(:email => "baz qux")
-end
-
-test "be able to find by the given attribute" do
-  assert @user1 == User.find(:email => "foo").first
-end
-
-test "raise an error if the parameter supplied is not a hash" do
-  begin
-    User.find(1)
-  rescue => ex
-  ensure
-    assert ex.kind_of?(ArgumentError)
-    assert ex.message == "You need to supply a hash with filters. If you want to find by ID, use User[id] instead."
-  end
-end
-
-test "avoid intersections with the all collection" do
-  assert "User:email:#{Ohm::Model.encode "foo"}" == User.find(:email => "foo").key.to_s
-
-  assert "~:User:email:Zm9v+User:activation_code:" ==
-    User.find(:email => "foo").find(:activation_code => "").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
-
-test "use a special namespace for set operations" do
-  assert User.find(:email => "foo", :activation_code => "bar").key.to_s.match(/^~:/)
-
-  assert Ohm.redis.keys("~:*").size > 0
-end
-
-test "allow multiple chained finds" do
-  assert 1 == User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").size
-end
-
-test "raise if the field is not indexed" do
-  assert_raise(Ohm::Model::IndexNotFound) do
-    User.find(:sandunga => "foo")
-  end
-end
-
-test "return nil if no results are found" do
-  assert User.find(:email => "foobar").empty?
-  assert nil == User.find(:email => "foobar").first
-end
-
-test "update indices when changing attribute values" do
-  @user1.email = "baz"
-  @user1.save
-
-  assert [] == User.find(:email => "foo").all
-  assert [@user1] == User.find(:email => "baz").all
-end
-
-test "remove from the index after deleting" do
-  @user2.delete
-
-  assert [] == User.find(:email => "bar").all
-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
-
-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
-
-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
-
-# 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")
-
-  assert_raise(Ohm::Model::IndexNotFound) { Event.find(:name => "Foo") }
-
-  class Event < Ohm::Model
-    index :name
-  end
-
-  # 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?
-
-  bar = Event.create(:name => "Bar")
-
-  # Bar was indexed properly.
-  assert bar == Event.find(:name => "Bar").first
-
-  # Saving all the objects populates the indices.
-  Event.all.each { |e| e.save }
-
-  # Now foo is indexed.
-  assert foo == Event.find(:name => "Foo").first
-end

data/test/mutex_test.rb

@@ -1,84 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-class Person < Ohm::Model
-  attribute :name
-end
-
-setup do
-  @p1 = Person.create :name => "Albert"
-  @p2 = Person[1]
-end
-
-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
-
-  p2 = Thread.new do
-    sleep 0.01
-    @p2.mutex do
-      t2 = Time.now
-    end
-  end
-
-  p1.join
-  p2.join
-  assert t2 > t1
-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
-
-test "work if two clients are fighting for the lock" do
-  @p1.send(:lock!)
-  @p3 = Person[1]
-  @p4 = Person[1]
-
-  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
-
-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!)
-
-  threads = []
-
-  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
-    end
-  end
-
-  threads.each { |t| t.join }
-  assert n * m == @candidate.votes
-end