remodel 0.4.2 → 0.5.0

data/test/test_entity_shortnames.rb

@@ -1,36 +0,0 @@
-require 'helper'
-
-class TestEntityShortnames < Test::Unit::TestCase
-
-  class Bar < Remodel::Entity
-    property :foo, :short => 'z'
-  end
-
-  context "[short names]" do
-    setup do
-      @bar = Bar.create(context, :foo => 42)
-    end
-
-    should "be used when storing properties" do
-      serialized = redis.hget(context.key, @bar.key)
-      assert !serialized.match(/foo/)
-      assert serialized.match(/z/)
-    end
-
-    should "work in roundtrip" do
-      @bar.reload
-      assert_equal 42, @bar.foo
-    end
-
-    should "not be used in as_json" do
-      assert !@bar.as_json.has_key?(:z)
-      assert @bar.as_json.has_key?(:foo)
-    end
-
-    should "not be used in inspect" do
-      assert !@bar.inspect.match(/z/)
-      assert @bar.inspect.match(/foo/)
-    end
-  end
-
-end

data/test/test_many_to_many.rb

@@ -1,77 +0,0 @@
-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(context).groups
-      assert_equal [], Group.new(context).members
-    end
-
-    context "create" do
-      should "add a new group to both associations" do
-        tim = Person.create(context, :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(context, :name => 'rug-b')
-        tim = rugb.members.create :name => 'tim'
-        assert_equal [rugb], tim.groups
-      end
-    end
-
-    context "add" do
-      setup do
-        @tim = Person.create(context, :name => 'tim')
-        @rugb = Group.create(context, :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(context, :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

@@ -1,117 +0,0 @@
-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(context).respond_to?(:pieces)
-      end
-
-      should "return an empty list by default" do
-        assert_equal [], Puzzle.create(context).pieces
-      end
-      
-      should "return any existing children" do
-        puzzle = Puzzle.create(context)
-        red_piece = Piece.create(context, :color => 'red')
-        blue_piece = Piece.create(context, :color => 'blue')
-        value = JSON.generate([red_piece.key, blue_piece.key])
-        redis.hset(context.key, "#{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(context)
-        red_piece = Piece.create(context, :color => 'red')
-        value = JSON.generate([red_piece.key, red_piece.key])
-        redis.hset(context.key, "#{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(context).pieces.respond_to?(:create)
-        end
-
-        should "work without attributes" do
-          puzzle = Puzzle.create(context)
-          piece = puzzle.pieces.create
-          assert piece.is_a?(Piece)
-        end
-
-        should "create and store a new child" do
-          puzzle = Puzzle.create(context)
-          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(context, :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(context)
-          piece = Piece.create(context, :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(context)
-          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(context)
-      piece = puzzle.pieces.create :color => 'black'
-      redis.hdel(context.key, "#{puzzle.key}_pieces")
-      puzzle.reload
-      assert_equal [], puzzle.pieces
-    end
-  end
-
-end

data/test/test_one_to_many.rb

@@ -1,96 +0,0 @@
-require 'helper'
-
-
-class TestOneToMany < Test::Unit::TestCase
-
-  class Piece < Remodel::Entity
-    has_one :puzzle, :class => 'TestOneToMany::Puzzle', :reverse => 'pieces'
-    property :color
-  end
-
-  class Puzzle < Remodel::Entity
-    has_many :pieces, :class => 'TestOneToMany::Piece', :reverse => 'puzzle'
-    property :topic
-  end
-
-  context "has_one" do
-    context "association getter" do
-      should "exist" do
-        assert Piece.create(context).respond_to?(:puzzle)
-      end
-
-      should "return nil by default" do
-        assert_nil Piece.create(context).puzzle
-      end
-
-      should "return the associated entity" do
-        puzzle = Puzzle.create(context, :topic => 'animals')
-        piece = Piece.create(context)
-        redis.hset(context.key, "#{piece.key}_puzzle", puzzle.key)
-        assert_equal 'animals', piece.puzzle.topic
-      end
-    end
-
-    context "association setter" do
-      should "exist" do
-        assert Piece.create(context).respond_to?(:'puzzle=')
-      end
-
-      should "store the key of the associated entity" do
-        puzzle = Puzzle.create(context)
-        piece = Piece.create(context)
-        piece.puzzle = puzzle
-        assert_equal puzzle.key, redis.hget(context.key, "#{piece.key}_puzzle")
-      end
-
-      should "add the entity to the reverse association" do
-        puzzle = Puzzle.create(context)
-        piece = Piece.create(context)
-        piece.puzzle = puzzle
-        assert_equal 1, puzzle.pieces.size
-        assert_equal piece.id, puzzle.pieces.first.id
-      end
-      
-      should "remove the entity from the old reverse association" do
-        puzzle = Puzzle.create(context)
-        piece = puzzle.pieces.create
-        new_puzzle = Puzzle.create(context)
-        piece.puzzle = new_puzzle
-        assert_equal [], puzzle.reload.pieces
-      end
-
-      should "be settable to nil" do
-        piece = Piece.create(context)
-        piece.puzzle = nil
-        assert_nil piece.puzzle
-      end
-
-      should "remove the key if set to nil" do
-        piece = Piece.create(context)
-        piece.puzzle = Puzzle.create(context)
-        piece.puzzle = nil
-        assert_nil redis.hget(piece.context, "#{piece.key}_puzzle")
-      end
-
-      should "remove the entity from the reverse association if set to nil" do
-        puzzle = Puzzle.create(context)
-        piece = Piece.create(context)
-        piece.puzzle = puzzle
-        piece.puzzle = nil
-        puzzle.reload
-        assert_equal 0, puzzle.pieces.size
-      end
-    end
-  end
-
-  context "reload" do
-    should "reset has_one associations" do
-      piece = Piece.create(context, :color => 'black')
-      piece.puzzle = Puzzle.create(context)
-      redis.hdel(context.key, "#{piece.key}_puzzle")
-      piece.reload
-      assert_nil piece.puzzle
-    end
-  end
-
-end

data/test/test_one_to_one.rb

@@ -1,57 +0,0 @@
-require 'helper'
-
-class TestOneToOne < Test::Unit::TestCase
-
-  class Man < Remodel::Entity
-    has_one :wife, :class => 'TestOneToOne::Woman', :reverse => 'husband'
-    property :name
-  end
-
-  class Woman < Remodel::Entity
-    has_one :husband, :class => 'TestOneToOne::Man', :reverse => 'wife'
-    property :name
-  end
-
-  context "both associations" do
-    should "be nil by default" do
-      assert_equal nil, Man.new(context).wife
-      assert_equal nil, Woman.new(context).husband
-    end
-
-    context "setter" do
-      setup do
-        @bill = Man.create(context, :name => 'Bill')
-        @mary = Woman.create(context, :name => 'Mary')
-      end
-
-      context "non-nil value" do
-        should "also set husband" do
-          @bill.wife = @mary
-          assert_equal @bill, @mary.husband
-        end
-
-        should "also set wife" do
-          @mary.husband = @bill
-          assert_equal @mary, @bill.wife
-        end
-      end
-
-      context "nil value" do
-        setup do
-          @bill.wife = @mary
-        end
-
-        should "also clear husband" do
-          @bill.wife = nil
-          assert_equal nil, @mary.husband
-        end
-
-        should "also clear wife" do
-          @mary.husband = nil
-          assert_equal nil, @bill.wife
-        end
-      end
-    end
-  end
-
-end