remodel 0.1.4 → 0.3.0

data/test/test_entity.rb

@@ -13,35 +13,25 @@ class TestEntity < Test::Unit::TestCase
 
   context "new" do
     should "set properties" do
-      foo = Foo.new :x => 1, :y => 2
-      assert 1, foo.x
-      assert 2, foo.y
+      foo = Foo.new('cx', :x => 1, :y => 2)
+      assert_equal 1, foo.x
+      assert_equal 2, foo.y
     end
 
     should "ignore undefined properties" do
-      foo = Foo.new :z => 3
+      foo = Foo.new('cx', :z => 3)
       assert foo.instance_eval { !@attributes.key? :z }
     end
 
     should "not set the key" do
-      foo = Foo.new :x => 23
+      foo = Foo.new('cx', :x => 23)
       assert_equal nil, foo.key
     end
 
     should "not set the id" do
-      foo = Foo.new :x => 23
+      foo = Foo.new('cx', :x => 23)
       assert_equal nil, foo.id
     end
-
-    should "use default values for missing properties" do
-      bar = Bar.new
-      assert_equal 123, bar.d
-    end
-
-    should "not use default values for given properties" do
-      bar = Bar.new :d => 'cool'
-      assert_equal 'cool', bar.d
-    end
   end
 
   context "create" do
@@ -50,47 +40,37 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "work without attributes" do
-      foo = Foo.create
+      foo = Foo.create('cx')
       assert foo.is_a?(Foo)
     end
 
     should "give the entity a key based on the class name" do
-      assert_equal 'f:1', Foo.create.key
-      assert_equal 'b:1', Bar.create.key
-      assert_equal 'b:2', Bar.create.key
+      assert_equal 'f1', Foo.create('cx').key
+      assert_equal 'b1', Bar.create('cx').key
+      assert_equal 'b2', Bar.create('cx').key
     end
 
     should "give the entity an id which is unique per entity class" do
-      assert_equal 1, Foo.create.id
-      assert_equal 1, Bar.create.id
-      assert_equal 2, Bar.create.id
+      assert_equal 1, Foo.create('cx').id
+      assert_equal 1, Bar.create('cx').id
+      assert_equal 2, Bar.create('cx').id
     end
 
     should "store the entity under its key" do
-      foo = Foo.create :x => 'hello', :y => false
-      assert redis.exists(foo.key)
+      foo = Foo.create('cx', :x => 'hello', :y => false)
+      assert redis.hexists('cx', foo.key)
     end
 
     should "store all properties" do
-      foo = Foo.create :x => 'hello', :y => false
+      foo = Foo.create('cx', :x => 'hello', :y => false)
       foo.reload
       assert_equal 'hello', foo.x
       assert_equal false, foo.y
     end
 
     should "not store the key as a property" do
-      foo = Foo.create :x => 'hello', :y => false
-      assert !(/f:1/ =~ redis.get(foo.key))
-    end
-
-    should "use default values for missing properties" do
-      bar = Bar.create
-      assert_equal 123, bar.d
-    end
-
-    should "not use default values for given properties" do
-      bar = Bar.create :d => 'cool'
-      assert_equal 'cool', bar.d
+      foo = Foo.create('cx', :x => 'hello', :y => false)
+      assert !(/f:1/ =~ redis.hget('cx', foo.key))
     end
   end
 
@@ -100,18 +80,18 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "give the entity a key, if necessary" do
-      foo = Foo.new.save
+      foo = Foo.new('cx').save
       assert foo.key
     end
 
     should "store the entity under its key" do
-      foo = Foo.new :x => 'hello', :y => false
+      foo = Foo.new('cx', :x => 'hello', :y => false)
       foo.save
-      assert redis.exists(foo.key)
+      assert redis.hexists(foo.context, foo.key)
     end
 
     should "store all properties" do
-      foo = Foo.new :x => 'hello', :y => false
+      foo = Foo.new('cx', :x => 'hello', :y => false)
       foo.save
       foo.reload
       assert_equal 'hello', foo.x
@@ -121,11 +101,11 @@ class TestEntity < Test::Unit::TestCase
 
   context "reload" do
     setup do
-      @foo = Foo.create :x => 'hello', :y => true
+      @foo = Foo.create('cx', :x => 'hello', :y => true)
     end
 
     should "reload all properties" do
-      redis.set @foo.key, %q({"x":23,"y":"adios"})
+      redis.hset @foo.context, @foo.key, %q({"x":23,"y":"adios"})
       @foo.reload
       assert_equal 23, @foo.x
       assert_equal 'adios', @foo.y
@@ -144,19 +124,19 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "raise EntityNotFound if the entity does not exist any more" do
-      redis.del @foo.key
+      redis.hdel @foo.context, @foo.key
       assert_raise(Remodel::EntityNotFound) { @foo.reload }
     end
 
     should "raise EntityNotSaved if the entity was never saved" do
-      assert_raise(Remodel::EntityNotSaved) { Foo.new.reload }
+      assert_raise(Remodel::EntityNotSaved) { Foo.new('cx').reload }
     end
   end
 
   context "update" do
     setup do
       redis.flushdb
-      @foo = Foo.create :x => 'Tim', :y => true
+      @foo = Foo.create('cx', :x => 'Tim', :y => true)
     end
 
     should "set the given properties" do
@@ -173,25 +153,9 @@ class TestEntity < Test::Unit::TestCase
     end
   end
 
-  context "delete" do
-    setup do
-      redis.flushdb
-      @foo = Foo.create :x => 'Tim', :y => true
-    end
-
-    should "delete the given entity" do
-      @foo.delete
-      assert_nil redis.get(@foo.key)
-    end
-
-    should "ensure that the entity is persistent" do
-      assert_raise(Remodel::EntityNotSaved) { Foo.new.delete }
-    end
-  end
-
   context "to_json" do
     should "serialize to json" do
-      foo = Foo.new :x => 42, :y => true
+      foo = Foo.new('cx', :x => 42, :y => true)
       assert_match /"x":42/, foo.to_json
       assert_match /"y":true/, foo.to_json
     end
@@ -199,7 +163,7 @@ class TestEntity < Test::Unit::TestCase
 
   context "as_json" do
     should "serialize into a hash" do
-      foo = Foo.create :x => 42, :y => true
+      foo = Foo.create('cx', :x => 42, :y => true)
       expected = { :id => foo.id, :x => 42, :y => true }
       assert_equal expected, foo.as_json
     end
@@ -208,7 +172,7 @@ class TestEntity < Test::Unit::TestCase
   context "#set_key_prefix" do
     should "use the given key prefix" do
       class Custom < Remodel::Entity; set_key_prefix 'my'; end
-      assert_match /^my:\d+$/, Custom.create.key
+      assert_match /^my\d+$/, Custom.create('cx').key
     end
 
     should "ensure that the prefix is letters only" do
@@ -221,47 +185,34 @@ class TestEntity < Test::Unit::TestCase
   context "#find" do
     setup do
       redis.flushdb
-      @foo = Foo.create :x => 'hello', :y => 123
-      Foo.create :x => 'hallo', :y => 124
+      @foo = Foo.create('cx', :x => 'hello', :y => 123)
+      Foo.create('cx', :x => 'hallo', :y => 124)
     end
 
     should "find and load an entity by key" do
-      foo = Foo.find(@foo.key)
+      foo = Foo.find(@foo.context, @foo.key)
       assert_equal foo.x, @foo.x
       assert_equal foo.y, @foo.y
     end
 
     should "find and load an entity by id" do
-      foo = Foo.find(@foo.id)
+      foo = Foo.find(@foo.context, @foo.id)
       assert_equal foo.x, @foo.x
       assert_equal foo.y, @foo.y
     end
 
     should "reject a key which does not exist" do
-      assert_raise(Remodel::EntityNotFound) { Foo.find('x:66') }
+      assert_raise(Remodel::EntityNotFound) { Foo.find('cx', 'x66') }
     end
 
     should "reject an id which does not exist" do
-      assert_raise(Remodel::EntityNotFound) { Foo.find(66) }
-    end
-  end
-
-  context "#all" do
-    setup do
-      redis.flushdb
-      17.times { |i| Foo.create :x => 'hello', :y => i }
-      5.times { |i| Bar.create }
-    end
-
-    should "find all entities of the given class" do
-      assert_equal 17, Foo.all.size
-      assert_equal 5, Bar.all.size
+      assert_raise(Remodel::EntityNotFound) { Foo.find('cx', 66) }
     end
   end
 
   context "properties" do
     should "have property x" do
-      foo = Foo.new
+      foo = Foo.new('cx')
       foo.x = 23
       assert_equal 23, foo.x
       foo.x += 10
@@ -269,45 +220,45 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "not have property z" do
-      foo = Foo.new
+      foo = Foo.new('cx')
       assert_raise(NoMethodError) { foo.z }
       assert_raise(NoMethodError) { foo.z = 42 }
     end
 
     context "types" do
       should "work with nil" do
-        foo = Foo.create :x => nil
+        foo = Foo.create('cx', :x => nil)
         assert_equal nil, foo.reload.x
       end
 
       should "work with booleans" do
-        foo = Foo.create :x => false
+        foo = Foo.create('cx', :x => false)
         assert_equal false, foo.reload.x
       end
 
       should "work with integers" do
-        foo = Foo.create :x => -42
+        foo = Foo.create('cx', :x => -42)
         assert_equal -42, foo.reload.x
       end
 
       should "work with floats" do
-        foo = Foo.create :x => 3.141
+        foo = Foo.create('cx', :x => 3.141)
         assert_equal 3.141, foo.reload.x
       end
 
       should "work with strings" do
-        foo = Foo.create :x => 'hello'
+        foo = Foo.create('cx', :x => 'hello')
         assert_equal 'hello', foo.reload.x
       end
 
       should "work with lists" do
-        foo = Foo.create :x => [1, 2, 3]
+        foo = Foo.create('cx', :x => [1, 2, 3])
         assert_equal [1, 2, 3], foo.reload.x
       end
 
       should "work with hashes" do
         hash = { 'a' => 17, 'b' => 'test' }
-        foo = Foo.create :x => hash
+        foo = Foo.create('cx', :x => hash)
         assert_equal hash, foo.reload.x
       end
     end
@@ -315,8 +266,8 @@ class TestEntity < Test::Unit::TestCase
 
   context "#restore" do
     should "restore an entity from json" do
-      before = Foo.create :x => 42, :y => true
-      after = Foo.restore(before.key, before.to_json)
+      before = Foo.create('cx', :x => 42, :y => true)
+      after = Foo.restore(before.context, before.key, before.to_json)
       assert_equal before.key, after.key
       assert_equal before.x, after.x
       assert_equal before.y, after.y

data/test/test_entity_defaults.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class TestEntityDefaults < Test::Unit::TestCase
+
+  class Bar < Remodel::Entity
+    property :simple, :default => 123
+    property :array, :default => [1]
+    property :hash, :default => { :foo => 1 }
+  end
+
+  context "[default values]" do
+    should "be returned for missing properties" do
+      bar = Bar.new('cx')
+      assert_equal 123, bar.simple
+    end
+
+    should "be returned for properties that are nil" do
+      bar = Bar.new('cx', :simple => 'cool')
+      bar.simple = nil
+      assert_equal 123, bar.simple
+    end
+
+    should "not be returned for given properties" do
+      bar = Bar.new('cx', :simple => 'cool')
+      assert_equal 'cool', bar.simple
+    end
+
+    should "not be stored" do
+      bar = Bar.create('cx')
+      assert !(/123/ =~ redis.hget('cx', bar.key))
+    end
+
+    should "be returned by as_json" do
+      bar = Bar.new('cx')
+      assert_equal 123, bar.as_json[:simple]
+    end
+  end
+
+  context "[collections]" do
+    setup do
+      @bar, @baz = Bar.new('cx'), Bar.new('cx')
+    end
+
+    should "not share arrays" do
+      @bar.array[0] += 1
+      assert_equal [1], @baz.array
+    end
+
+    should "not share hashes" do
+      @bar.hash[:foo] = 42
+      assert_equal 1, @baz.hash[:foo]
+    end
+  end
+
+end

data/test/test_entity_delete.rb

@@ -0,0 +1,61 @@
+require 'helper'
+
+class TestEntityDelete < Test::Unit::TestCase
+
+  class Group < Remodel::Entity
+    has_many :members, :class => 'TestEntityDelete::Person'
+    has_one :room, :class => 'TestEntityDelete::Room'
+    property :name
+  end
+
+  class Person < Remodel::Entity
+    property :name
+  end
+
+  class Room < Remodel::Entity
+    property :name
+  end
+
+  context "delete" do
+    setup do
+      redis.flushdb
+      @group = Group.create('cx', :name => 'ruby user group')
+      @tim = @group.members.create(:name => 'Tim')
+      @group.members.create(:name => 'Ben')
+      @room = Room.create(:name => 'some office')
+      @group.room = @room
+      @group.reload
+    end
+
+    should "ensure that the entity is persistent" do
+      assert_raise(Remodel::EntityNotSaved) { Group.new('cx').delete }
+    end
+
+    should "delete the given entity" do
+      @group.delete
+      assert_nil redis.hget(@group.context, @group.key)
+    end
+
+    should "delete any associations in redis" do
+      @group.delete
+      assert_nil redis.hget(@group.context, "#{@group.key}_members")
+      assert_nil redis.hget(@group.context, "#{@group.key}_room")
+    end
+
+    context "has_one" do
+      should "be nil if deleted" do
+        @room.delete
+        assert_nil @group.room
+      end
+    end
+
+    context "has_many" do
+      should "be skipped if deleted" do
+        @tim.delete
+        assert_equal 1, @group.members.count
+      end
+    end
+
+  end
+  
+end

data/test/test_many_to_many.rb

@@ -14,19 +14,19 @@ class TestManyToMany < Test::Unit::TestCase
 
   context "both associations" do
     should "be empty by default" do
-      assert_equal [], Person.new.groups
-      assert_equal [], Group.new.members
+      assert_equal [], Person.new('cx').groups
+      assert_equal [], Group.new('cx').members
     end
 
     context "create" do
       should "add a new group to both associations" do
-        tim = Person.create :name => 'tim'
+        tim = Person.create('cx', :name => 'tim')
         rugb = tim.groups.create :name => 'rug-b'
         assert_equal [tim], rugb.members
       end
 
       should "add a new person to both associations" do
-        rugb = Group.create :name => 'rug-b'
+        rugb = Group.create('cx', :name => 'rug-b')
         tim = rugb.members.create :name => 'tim'
         assert_equal [rugb], tim.groups
       end
@@ -34,8 +34,8 @@ class TestManyToMany < Test::Unit::TestCase
 
     context "add" do
       setup do
-        @tim = Person.create :name => 'tim'
-        @rugb = Group.create :name => 'rug-b'
+        @tim = Person.create('cx', :name => 'tim')
+        @rugb = Group.create('cx', :name => 'rug-b')
       end
 
       should "add a new group to both associations" do
@@ -53,7 +53,7 @@ class TestManyToMany < Test::Unit::TestCase
 
     context "remove" do
       setup do
-        @tim = Person.create :name => 'tim'
+        @tim = Person.create('cx', :name => 'tim')
         @rugb = @tim.groups.create(:name => 'rug-b')
         @erlang = @tim.groups.create(:name => 'erlang')
         @aws = @tim.groups.create(:name => 'aws')

data/test/test_many_to_one.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'json'
 
 class TestManyToOne < Test::Unit::TestCase
 
@@ -15,35 +16,47 @@ class TestManyToOne < Test::Unit::TestCase
   context "has_many" do
     context "association" do
       should "exist" do
-        assert Puzzle.create.respond_to?(:pieces)
+        assert Puzzle.create('cx').respond_to?(:pieces)
       end
 
       should "return an empty list by default" do
-        assert_equal [], Puzzle.create.pieces
+        assert_equal [], Puzzle.create('cx').pieces
       end
-
+      
       should "return any existing children" do
-        puzzle = Puzzle.create
-        redis.rpush "#{puzzle.key}:pieces", Piece.create(:color => 'red').key
-        redis.rpush "#{puzzle.key}:pieces", Piece.create(:color => 'blue').key
+        puzzle = Puzzle.create('cx')
+        red_piece = Piece.create('cx', :color => 'red')
+        blue_piece = Piece.create('cx', :color => 'blue')
+        value = JSON.generate([red_piece.key, blue_piece.key])
+        redis.hset 'cx', "#{puzzle.key}_pieces", value
         assert_equal 2, puzzle.pieces.size
         assert_equal Piece, puzzle.pieces[0].class
         assert_equal 'red', puzzle.pieces[0].color
       end
 
+      should "not return any child multiple times" do
+        puzzle = Puzzle.create('cx')
+        red_piece = Piece.create('cx', :color => 'red')
+        value = JSON.generate([red_piece.key, red_piece.key])
+        redis.hset 'cx', "#{puzzle.key}_pieces", value
+        assert_equal 1, puzzle.pieces.size
+        assert_equal Piece, puzzle.pieces[0].class
+        assert_equal 'red', puzzle.pieces[0].color
+      end
+
       context "create" do
         should "have a create method" do
-          assert Puzzle.create.pieces.respond_to?(:create)
+          assert Puzzle.create('cx').pieces.respond_to?(:create)
         end
 
         should "work without attributes" do
-          puzzle = Puzzle.create
+          puzzle = Puzzle.create('cx')
           piece = puzzle.pieces.create
           assert piece.is_a?(Piece)
         end
 
         should "create and store a new child" do
-          puzzle = Puzzle.create
+          puzzle = Puzzle.create('cx')
           puzzle.pieces.create :color => 'green'
           assert_equal 1, puzzle.pieces.size
           puzzle.reload
@@ -53,7 +66,7 @@ class TestManyToOne < Test::Unit::TestCase
         end
 
         should "associate the created child with self" do
-          puzzle = Puzzle.create :topic => 'provence'
+          puzzle = Puzzle.create('cx', :topic => 'provence')
           piece = puzzle.pieces.create :color => 'green'
           assert_equal 'provence', piece.puzzle.topic
         end
@@ -61,8 +74,8 @@ class TestManyToOne < Test::Unit::TestCase
 
       context "add" do
         should "add the given entity to the association" do
-          puzzle = Puzzle.create
-          piece = Piece.create :color => 'white'
+          puzzle = Puzzle.create('cx')
+          piece = Piece.create('cx', :color => 'white')
           puzzle.pieces.add piece
           assert_equal 1, puzzle.pieces.size
           puzzle.reload
@@ -74,7 +87,7 @@ class TestManyToOne < Test::Unit::TestCase
 
       context "find" do
         setup do
-          @puzzle = Puzzle.create
+          @puzzle = Puzzle.create('cx')
           5.times { @puzzle.pieces.create :color => 'blue' }
         end
 
@@ -93,9 +106,9 @@ class TestManyToOne < Test::Unit::TestCase
 
   context "reload" do
     should "reset has_many associations" do
-      puzzle = Puzzle.create
+      puzzle = Puzzle.create('cx')
       piece = puzzle.pieces.create :color => 'black'
-      redis.del "#{puzzle.key}:pieces"
+      redis.hdel 'cx', "#{puzzle.key}_pieces"
       puzzle.reload
       assert_equal [], puzzle.pieces
     end

data/test/test_mappers.rb

@@ -15,7 +15,7 @@ class TestMappers < Test::Unit::TestCase
 
   context "create" do
     setup do
-      @item = Item.create :time => Time.at(1234567890), :date => Date.parse("1972-06-16")
+      @item = Item.create('cx', :time => Time.at(1234567890), :date => Date.parse("1972-06-16"))
     end
 
     should "store unmapped values" do
@@ -35,13 +35,13 @@ class TestMappers < Test::Unit::TestCase
     end
 
     should "serialize mapped values correctly" do
-      json = redis.get(@item.key)
+      json = redis.hget(@item.context, @item.key)
       assert_match /1234567890/, json
       assert_match /"1972-06-16"/, json
     end
 
     should "handle nil values" do
-      item = Item.create
+      item = Item.create('cx')
       assert_nil item.boolean
       assert_nil item.string
       assert_nil item.integer
@@ -53,14 +53,14 @@ class TestMappers < Test::Unit::TestCase
     end
 
     should "reject invalid types" do
-      assert_raise(Remodel::InvalidType) { Item.create :boolean => 'hello' }
-      assert_raise(Remodel::InvalidType) { Item.create :string => true }
-      assert_raise(Remodel::InvalidType) { Item.create :integer => 33.5 }
-      assert_raise(Remodel::InvalidType) { Item.create :float => 5 }
-      assert_raise(Remodel::InvalidType) { Item.create :array => {} }
-      assert_raise(Remodel::InvalidType) { Item.create :hash => [] }
-      assert_raise(Remodel::InvalidType) { Item.create :time => Date.new }
-      assert_raise(Remodel::InvalidType) { Item.create :date => Time.now }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :boolean => 'hello') }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :string => true) }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :integer => 33.5) }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :float => 5) }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :array => {}) }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :hash => []) }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :time => Date.new) }
+      assert_raise(Remodel::InvalidType) { Item.create('cx', :date => Time.now) }
     end
   end