ohm 0.1.5 → 1.0.0.alpha1

data/test/pipeline-performance.rb

@@ -0,0 +1,65 @@
+require_relative "helper"
+
+Ohm.flush
+
+class User < Ohm::Model
+  attribute :fname
+  attribute :lname
+  attribute :bday
+  attribute :gender
+  attribute :city
+  attribute :state
+  attribute :country
+  attribute :zip
+end
+
+create = lambda do |i|
+  User.new(fname: "John#{i}",
+           lname: "Doe#{i}",
+           bday: Time.now.to_s,
+           gender: "Male",
+           city: "Los Angeles",
+           state: "CA",
+           country: "US",
+           zip: "90210").save
+end
+
+10.times(&create)
+
+require "benchmark"
+
+t1 = Benchmark.realtime do
+  User.all.sort_by(:fname, order: "DESC ALPHA").each do |user|
+  end
+end
+
+t2 = Benchmark.realtime do
+  ids = User.key[:all].smembers
+
+  ids.each do |id|
+    User[id]
+  end
+end
+
+test "pipelined approach should be 1.5 at least times faster for 10 records" do
+  assert(t2 / t1 >= 1.5)
+end
+
+90.times(&create)
+
+t1 = Benchmark.realtime do
+  User.all.sort_by(:fname, order: "DESC ALPHA").each do |user|
+  end
+end
+
+t2 = Benchmark.realtime do
+  ids = User.key[:all].smembers
+
+  ids.each do |id|
+    User[id]
+  end
+end
+
+test "the pipelined approach should be 2 times faster for 100 records" do
+  assert(t2 / t1 >= 2)
+end

data/test/transactions.rb

@@ -0,0 +1,241 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "ohm/transaction"
+
+prepare do
+  Ohm.redis.del("foo")
+end
+
+setup do
+  Ohm.redis
+end
+
+test "basic functionality" do |db|
+  t = Ohm::Transaction.new
+  x = nil
+
+  t.watch("foo")
+
+  t.read do
+    x = db.get("foo")
+  end
+
+  t.write do
+    db.set("foo", x.to_i + 2)
+  end
+
+  t.commit(db)
+
+  assert_equal "2", db.get("foo")
+end
+
+test "new returns a transaction" do |db|
+  t1 = Ohm::Transaction.new do |t|
+    t.write do
+      db.set("foo", "bar")
+    end
+  end
+
+  t1.commit(db)
+
+  assert_equal "bar", db.get("foo")
+end
+
+test "transaction local storage" do |db|
+  t1 = Ohm::Transaction.new do |t|
+    t.read do |s|
+      s.foo = db.type("foo")
+    end
+
+    t.write do |s|
+      db.set("foo", s.foo.reverse)
+    end
+  end
+
+  t1.commit(db)
+
+  assert_equal "enon", db.get("foo")
+end
+
+test "composed transaction" do |db|
+  t1 = Ohm::Transaction.new do |t|
+    t.watch("foo")
+
+    t.write do |s|
+      db.set("foo", "bar")
+    end
+  end
+
+  t2 = Ohm::Transaction.new do |t|
+    t.watch("foo")
+
+    t.write do |s|
+      db.set("foo", "baz")
+    end
+  end
+
+  t3 = Ohm::Transaction.new
+  t3.append(t1)
+  t3.append(t2)
+  t3.commit(db)
+
+  assert_equal "baz", db.get("foo")
+
+  t4 = Ohm::Transaction.new
+  t4.append(t2)
+  t4.append(t1)
+  t4.commit(db)
+
+  assert_equal "bar", db.get("foo")
+
+  t5 = Ohm::Transaction.new
+  t5.append(t4)
+  t5.commit(db)
+
+  assert_equal "bar", db.get("foo")
+
+  assert_equal Set.new(["foo"]), t5.phase[:watch]
+  assert_equal 2, t5.phase[:write].size
+end
+
+test "composing transactions with append" do |db|
+  t1 = Ohm::Transaction.new do |t|
+    t.write do
+      db.set("foo", "bar")
+    end
+  end
+
+  t2 = Ohm::Transaction.new do |t|
+    t.write do
+      db.set("foo", "baz")
+    end
+  end
+
+  t1.append(t2)
+  t1.commit(db)
+
+  assert_equal "baz", db.get("foo")
+
+  t2.append(t1)
+  t2.commit(db)
+
+  assert_equal "bar", db.get("foo")
+end
+
+test "appending or prepending is determined by when append is called" do |db|
+  t1 = Ohm::Transaction.new do |t|
+    t.write do
+      db.set("foo", "bar")
+    end
+  end
+
+  t2 = Ohm::Transaction.new do |t|
+    t.append(t1)
+
+    t.write do
+      db.set("foo", "baz")
+    end
+  end
+
+  t3 = Ohm::Transaction.new do |t|
+    t.write do
+      db.set("foo", "baz")
+    end
+
+    t.append(t1)
+  end
+
+  t2.commit(db)
+
+  assert_equal "baz", db.get("foo")
+
+  t3.commit(db)
+
+  assert_equal "bar", db.get("foo")
+end
+
+test "storage in composed transactions" do |db|
+  t1 = Ohm::Transaction.new do |t|
+    t.read do |s|
+      s.foo = db.type("foo")
+    end
+  end
+
+  t2 = Ohm::Transaction.new do |t|
+    t.write do |s|
+      db.set("foo", s.foo.reverse)
+    end
+  end
+
+  t1.append(t2).commit(db)
+
+  assert_equal "enon", db.get("foo")
+end
+
+test "storage entries can't be overriden" do |db|
+  t1 = Ohm::Transaction.new do |t|
+    t.read do |s|
+      s.foo = db.type("foo")
+    end
+  end
+
+  t2 = Ohm::Transaction.new do |t|
+    t.read do |s|
+      s.foo = db.exists("foo")
+    end
+  end
+
+  assert_raise Ohm::Transaction::Store::EntryAlreadyExistsError do
+    t1.append(t2).commit(db)
+  end
+end
+
+__END__
+# We leave this here to indicate what the past behavior was with
+# model transactions.
+
+class Post < Ohm::Model
+  attribute :body
+  attribute :state
+  index :state
+
+  def before_save
+    self.body = body.to_s.strip
+  end
+
+  def before_create
+    self.state = "draft"
+  end
+end
+
+test "transactions in models" do |db|
+  p = Post.new(body: " foo ")
+
+  db.set "csv:foo", "A,B"
+
+  t1 = Ohm::Transaction.define do |t|
+    t.watch("csv:foo")
+
+    t.read do |s|
+      s.csv = db.get("csv:foo")
+    end
+
+    t.write do |s|
+      db.set("csv:foo", s.csv + "," + "C")
+    end
+  end
+
+  main = Ohm::Transaction.new(p.transaction_for_create, t1)
+  main.commit(db)
+
+  # Verify the Post transaction proceeded without a hitch
+  p = Post[p.id]
+
+  assert_equal "draft", p.state
+  assert_equal "foo", p.body
+  assert Post.find(state: "draft").include?(p)
+
+  # Verify that the second transaction happened
+  assert_equal "A,B,C", db.get("csv:foo")
+end

data/test/uniques.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class User < Ohm::Model
+  attribute :email
+  unique :email
+  unique :provider
+
+  def self.[](id)
+    super(id.to_i)
+  end
+
+  def provider
+    email[/@(.*?).com/, 1]
+  end
+end
+
+setup do
+  User.create(email: "a@a.com")
+end
+
+test "findability" do |u|
+  assert_equal u, User.with(:email, "a@a.com")
+end
+
+test "raises when it already exists during create" do
+  assert_raise Ohm::UniqueIndexViolation do
+    User.create(email: "a@a.com")
+  end
+end
+
+test "raises when it already exists during save" do
+  u = User.create(email: "b@b.com")
+  u.email = "a@a.com"
+
+  assert_raise Ohm::UniqueIndexViolation do
+    u.save
+  end
+end
+
+test "doesn't raise when saving again and again" do |u|
+  ex = nil
+
+  begin
+    User[u.id].save
+  rescue Exception => e
+    ex = e
+  end
+
+  assert_equal nil, ex
+end
+
+test "removes the previous index when changing" do
+  u = User.create(email: "c@c.com")
+  u.update(email: "d@d.com")
+
+  assert_equal nil, User.with(:email, "c@c.com")
+  assert_equal nil, User.key[:unique][:email].hget("c@c.com")
+  assert_equal u, User.with(:email, "d@d.com")
+end
+
+test "removes the previous index when deleting" do |u|
+  u.delete
+
+  assert_equal nil, User.with(:email, "a@a.com")
+  assert_equal nil, User.key[:unique][:email].hget("a@a.com")
+end
+
+test "unique virtual attribute" do
+  u = User.create(email: "foo@yahoo.com")
+
+  assert_equal u, User.with(:provider, "yahoo")
+
+  # Yahoo should be allowed because this user is the one reserved for it.
+  u.update(email: "bar@yahoo.com")
+
+  # `a` is not allowed though.
+  assert_raise Ohm::UniqueIndexViolation do
+    u.update(email: "bar@a.com")
+  end
+
+  # And so is yahoo if we try creating a different user.
+  assert_raise Ohm::UniqueIndexViolation do
+    User.create(email: "baz@yahoo.com")
+  end
+end

data/test/{associations_test.rb → unused/associations_test.rb}

@@ -63,12 +63,12 @@ test "be cached in an instance variable" do
 
   @post.update(:author => Person.create(:name => "Bertrand"))
 
-  assert "Bertrand" == @post.author.name
-  assert @post.author.object_id == @post.author.object_id
+  assert_equal "Bertrand", @post.author.name
+  assert_equal @post.author.object_id, @post.author.object_id
 
   @post.update(:author_id => Person.create(:name => "Charles").id)
 
-  assert "Charles" == @post.author.name
+  assert_equal "Charles", @post.author.name
 end
 
 setup do

data/test/{validations_test.rb → validations.rb}

@@ -18,7 +18,7 @@ end
 class Validatable
   attr_accessor :name
 
-  include Ohm::Validations
+  include Scrivener::Validations
 end
 
 # A new model with validations
@@ -30,19 +30,19 @@ scope do
   # That must have a present name
   scope do
     test "not be created if the name is never assigned" do |event|
-      event.create
+      event.save
       assert event.new?
     end
 
     test "not be created if the name assigned is empty" do |event|
       event.name = ""
-      event.create
+      event.save
       assert event.new?
     end
 
     test "be created if the name assigned is not empty" do |event|
       event.name = "hello"
-      event.create
+      event.save
       assert event.id
     end
 
@@ -50,7 +50,7 @@ scope do
     scope do
       test "not be created if the name doesn't match /^\w+$/" do |event|
         event.name = "hello-world"
-        event.create
+        event.save
         assert event.new?
       end
     end
@@ -65,10 +65,10 @@ scope do
 
       event.name = "foo"
       event.place = "bar"
-      event.create
+      event.save
 
       assert event.new?
-      assert [[:capacity, :not_numeric]] == event.errors
+      assert_equal({capacity: [:not_numeric]}, event.errors)
     end
 
     test "fail when the value is not numeric" do |event|
@@ -79,10 +79,10 @@ scope do
       event.name = "foo"
       event.place = "bar"
       event.capacity = "baz"
-      event.create
+      event.save
 
       assert event.new?
-      assert [[:capacity, :not_numeric]] == event.errors
+      assert_equal({capacity: [:not_numeric]}, event.errors)
     end
 
     test "succeed when the value is numeric" do |event|
@@ -93,62 +93,11 @@ scope do
       event.name = "foo"
       event.place = "bar"
       event.capacity = 42
-      event.create
+      event.save
 
       assert event.id
     end
   end
-
-  # That must have a unique name
-  scope do
-    test "fail when the value already exists" do |event|
-      def event.validate
-        assert_unique :name
-      end
-
-      Event.create(:name => "foo")
-      event.name = "foo"
-      event.create
-
-      assert event.new?
-      assert [[:name, :not_unique]] == event.errors
-    end
-  end
-
-  # 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.create(:name => "foo", :place => "bar")
-      event.name = "foo"
-      event.place = "bar"
-      event.create
-
-      assert event.new?
-      assert [[[:name, :place], :not_unique]] == event.errors
-
-      event.place = "baz"
-      event.create
-
-      assert event.valid?
-    end
-  end
-
-  # That defines a unique validation on a non indexed attribute
-  scope do
-    test "raise ArgumentError" do |event|
-      def event.validate
-        assert_unique :capacity
-      end
-
-      assert_raise(Ohm::Model::IndexNotFound) do
-        event.valid?
-      end
-    end
-  end
 end
 
 # An existing model with a valid name
@@ -192,28 +141,29 @@ scope do
   scope do
     test "add errors to a collection" do |target|
       def target.validate
-        assert(false, "Something bad")
+        assert(false, ["Attribute", "Something bad"])
       end
 
       target.validate
 
-      assert ["Something bad"] == target.errors
+      assert_equal({ "Attribute" => ["Something bad"] }, target.errors)
     end
 
     test "allow for nested validations" do |target|
       def target.validate
-        if assert(true, "No error")
-          assert(false, "Chained error")
+        if assert(true, ["Attribute", "No error"])
+          assert(false, ["Attribute", "Chained error"])
         end
 
-        if assert(false, "Parent error")
-          assert(false, "No chained error")
+        if assert(false, ["Attribute", "Parent error"])
+          assert(false, ["Attribute", "No chained error"])
         end
       end
 
       target.validate
 
-      assert ["Chained error", "Parent error"] == target.errors
+      expected = {"Attribute"=>["Chained error", "Parent error"]}
+      assert_equal expected, target.errors
     end
   end
 
@@ -232,14 +182,14 @@ scope do
     test "fail when the attribute is nil" do |target|
       target.validate
 
-      assert [[:name, :not_present]] == target.errors
+      assert_equal({ name: [:not_present] }, target.errors)
     end
 
     test "fail when the attribute is empty" do |target|
       target.name = ""
       target.validate
 
-      assert [[:name, :not_present]] == target.errors
+      assert_equal({ name: [:not_present] }, target.errors)
     end
   end
 end