remodel-h-r19 0.2.4

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+require File.dirname(__FILE__) + '/../lib/remodel-h.rb'
+
+class Test::Unit::TestCase
+
+  def redis
+    Remodel.redis
+  end
+  
+end

data/test/test_entity.rb

@@ -0,0 +1,297 @@
+require 'helper'
+
+class Foo < Remodel::Entity
+  property :x
+  property :y
+end
+
+class Bar < Remodel::Entity
+  property :d, :default => 123
+end
+
+class TestEntity < Test::Unit::TestCase
+
+  context "new" do
+    should "set properties" do
+      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('cx', :z => 3)
+      assert foo.instance_eval { !@attributes.key? :z }
+    end
+    
+    should "not set the key" do
+      foo = Foo.new('cx', :x => 23)
+      assert_equal nil, foo.key
+    end
+
+    should "not set the id" do
+      foo = Foo.new('cx', :x => 23)
+      assert_equal nil, foo.id
+    end
+
+    should "use default values for missing properties" do
+      bar = Bar.new('cx')
+      assert_equal 123, bar.d
+    end
+
+    should "not use default values for given properties" do
+      bar = Bar.new('cx', :d => 'cool')
+      assert_equal 'cool', bar.d
+    end
+  end
+
+  context "create" do
+    setup do
+      redis.flushdb
+    end
+
+    should "work without attributes" do
+      foo = Foo.create('cx')
+      assert foo.is_a?(Foo)
+    end
+
+    should "give the entity a key based on the class name" do
+      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('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('cx', :x => 'hello', :y => false)
+      assert redis.hexists('cx', foo.key)
+    end
+
+    should "store all properties" do
+      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('cx', :x => 'hello', :y => false)
+      assert !(/f:1/ =~ redis.hget('cx', foo.key))
+    end
+
+    should "use default values for missing properties" do
+      bar = Bar.create('cx')
+      assert_equal 123, bar.d
+    end
+
+    should "not use default values for given properties" do
+      bar = Bar.create('cx', :d => 'cool')
+      assert_equal 'cool', bar.d
+    end
+  end
+
+  context "save" do
+    setup do
+      redis.flushdb
+    end
+
+    should "give the entity a key, if necessary" do
+      foo = Foo.new('cx').save
+      assert foo.key
+    end
+
+    should "store the entity under its key" do
+      foo = Foo.new('cx', :x => 'hello', :y => false)
+      foo.save
+      assert redis.hexists(foo.context, foo.key)
+    end
+
+    should "store all properties" do
+      foo = Foo.new('cx', :x => 'hello', :y => false)
+      foo.save
+      foo.reload
+      assert_equal 'hello', foo.x
+      assert_equal false, foo.y
+    end
+  end
+
+  context "reload" do
+    setup do
+      @foo = Foo.create('cx', :x => 'hello', :y => true)
+    end
+
+    should "reload all properties" do
+      redis.hset @foo.context, @foo.key, %q({"x":23,"y":"adios"})
+      @foo.reload
+      assert_equal 23, @foo.x
+      assert_equal 'adios', @foo.y
+    end
+
+    should "keep the key" do
+      key = @foo.key
+      @foo.reload
+      assert_equal key, @foo.key
+    end
+
+    should "stay the same object" do
+      id = @foo.object_id
+      @foo.reload
+      assert_equal id, @foo.object_id
+    end
+
+    should "raise EntityNotFound if the entity does not exist any more" do
+      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('cx').reload }
+    end
+  end
+
+  context "update" do
+    setup do
+      redis.flushdb
+      @foo = Foo.create('cx', :x => 'Tim', :y => true)
+    end
+
+    should "set the given properties" do
+      @foo.update(:x => 12, :y => 'Jan')
+      assert_equal 12, @foo.x
+      assert_equal 'Jan', @foo.y
+    end
+
+    should "save the entity" do
+      @foo.update(:x => 12, :y => 'Jan')
+      @foo.reload
+      assert_equal 12, @foo.x
+      assert_equal 'Jan', @foo.y
+    end
+  end
+
+  context "to_json" do
+    should "serialize to json" do
+      foo = Foo.new('cx', :x => 42, :y => true)
+      assert_match /"x":42/, foo.to_json
+      assert_match /"y":true/, foo.to_json
+    end
+  end
+
+  context "as_json" do
+    should "serialize into a hash" do
+      foo = Foo.create('cx', :x => 42, :y => true)
+      expected = { :id => foo.id, :x => 42, :y => true }
+      assert_equal expected, foo.as_json
+    end
+  end
+
+  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('cx').key
+    end
+
+    should "ensure that the prefix is letters only" do
+      assert_raise(Remodel::InvalidKeyPrefix) do
+        class InvalidPrefix < Remodel::Entity; set_key_prefix '666'; end
+      end
+    end
+  end
+
+  context "#find" do
+    setup do
+      redis.flushdb
+      @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.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.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('cx', 'x:66') }
+    end
+
+    should "reject an id which does not exist" do
+      assert_raise(Remodel::EntityNotFound) { Foo.find('cx', 66) }
+    end
+  end
+
+  context "properties" do
+    should "have property x" do
+      foo = Foo.new('cx')
+      foo.x = 23
+      assert_equal 23, foo.x
+      foo.x += 10
+      assert_equal 33, foo.x
+    end
+
+    should "not have property z" do
+      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('cx', :x => nil)
+        assert_equal nil, foo.reload.x
+      end
+
+      should "work with booleans" do
+        foo = Foo.create('cx', :x => false)
+        assert_equal false, foo.reload.x
+      end
+
+      should "work with integers" do
+        foo = Foo.create('cx', :x => -42)
+        assert_equal -42, foo.reload.x
+      end
+
+      should "work with floats" do
+        foo = Foo.create('cx', :x => 3.141)
+        assert_equal 3.141, foo.reload.x
+      end
+
+      should "work with strings" do
+        foo = Foo.create('cx', :x => 'hello')
+        assert_equal 'hello', foo.reload.x
+      end
+
+      should "work with lists" do
+        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('cx', :x => hash)
+        assert_equal hash, foo.reload.x
+      end
+    end
+  end
+
+  context "#restore" do
+    should "restore an entity from json" do
+      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
+    end
+  end
+
+end

data/test/test_entity_delete.rb

@@ -0,0 +1,45 @@
+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')
+      @group.members.create(:name => 'Tim')
+      @group.members.create(:name => 'Ben')
+      @group.room = Room.create(:name => 'some office')
+    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
+
+  end
+
+end

data/test/test_many_to_many.rb

@@ -0,0 +1,77 @@
+require 'helper'
+
+class TestManyToMany < Test::Unit::TestCase
+
+  class Person < Remodel::Entity
+    has_many :groups, :class => 'TestManyToMany::Group', :reverse => 'members'
+    property :name
+  end
+
+  class Group < Remodel::Entity
+    has_many :members, :class => 'TestManyToMany::Person', :reverse => 'groups'
+    property :name
+  end
+
+  context "both associations" do
+    should "be empty by default" do
+      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('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('cx', :name => 'rug-b')
+        tim = rugb.members.create :name => 'tim'
+        assert_equal [rugb], tim.groups
+      end
+    end
+
+    context "add" do
+      setup do
+        @tim = Person.create('cx', :name => 'tim')
+        @rugb = Group.create('cx', :name => 'rug-b')
+      end
+
+      should "add a new group to both associations" do
+        @tim.groups.add(@rugb)
+        assert_equal [@tim], @rugb.members
+        assert_equal [@rugb], @tim.groups
+      end
+
+      should "add a new person to both associations" do
+        @rugb.members.add(@tim)
+        assert_equal [@tim], @rugb.members
+        assert_equal [@rugb], @tim.groups
+      end
+    end
+
+    context "remove" do
+      setup do
+        @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')
+      end
+
+      should "remove a group from both associations" do
+        @tim.groups.remove(@erlang)
+        assert_equal [@rugb, @aws], @tim.groups
+        assert_equal [], @erlang.members
+      end
+
+      should "remove a person from both associations" do
+        @erlang.members.remove(@tim)
+        assert_equal [@rugb, @aws], @tim.groups
+        assert_equal [], @erlang.members
+      end
+
+    end
+  end
+
+end

data/test/test_many_to_one.rb

@@ -0,0 +1,107 @@
+require 'helper'
+require 'json'
+
+class TestManyToOne < Test::Unit::TestCase
+
+  class Puzzle < Remodel::Entity
+    has_many :pieces, :class => 'TestManyToOne::Piece', :reverse => 'puzzle'
+    property :topic
+  end
+
+  class Piece < Remodel::Entity
+    has_one :puzzle, :class => 'TestManyToOne::Puzzle'
+    property :color
+  end
+
+  context "has_many" do
+    context "association" do
+      should "exist" do
+        assert Puzzle.create('cx').respond_to?(:pieces)
+      end
+
+      should "return an empty list by default" do
+        assert_equal [], Puzzle.create('cx').pieces
+      end
+
+      should "return any existing children" do
+        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
+
+      context "create" do
+        should "have a create method" do
+          assert Puzzle.create('cx').pieces.respond_to?(:create)
+        end
+
+        should "work without attributes" do
+          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('cx')
+          puzzle.pieces.create :color => 'green'
+          assert_equal 1, puzzle.pieces.size
+          puzzle.reload
+          assert_equal 1, puzzle.pieces.size
+          assert_equal Piece, puzzle.pieces[0].class
+          assert_equal 'green', puzzle.pieces[0].color
+        end
+
+        should "associate the created child with self" do
+          puzzle = Puzzle.create('cx', :topic => 'provence')
+          piece = puzzle.pieces.create :color => 'green'
+          assert_equal 'provence', piece.puzzle.topic
+        end
+      end
+
+      context "add" do
+        should "add the given entity to the association" do
+          puzzle = Puzzle.create('cx')
+          piece = Piece.create('cx', :color => 'white')
+          puzzle.pieces.add piece
+          assert_equal 1, puzzle.pieces.size
+          puzzle.reload
+          assert_equal 1, puzzle.pieces.size
+          assert_equal Piece, puzzle.pieces[0].class
+          assert_equal 'white', puzzle.pieces[0].color
+        end
+      end
+
+      context "find" do
+        setup do
+          @puzzle = Puzzle.create('cx')
+          5.times { @puzzle.pieces.create :color => 'blue' }
+        end
+
+        should "find the element with the given id" do
+          piece = @puzzle.pieces[2]
+          assert_equal piece, @puzzle.pieces.find(piece.id)
+        end
+
+        should "raise an exception if no element with the given id exists" do
+          assert_raises(Remodel::EntityNotFound) { @puzzle.pieces.find(-1) }
+        end
+      end
+
+    end
+  end
+
+  context "reload" do
+    should "reset has_many associations" do
+      puzzle = Puzzle.create('cx')
+      piece = puzzle.pieces.create :color => 'black'
+      redis.hdel 'cx', "#{puzzle.key}_pieces"
+      puzzle.reload
+      assert_equal [], puzzle.pieces
+    end
+  end
+
+end