toystore 0.9.0 → 0.10.0

data/spec/toy/reference_spec.rb

@@ -226,7 +226,7 @@ describe Toy::Reference do
 
     it "unmemoizes the list" do
       @game.user.should == @user
-      @game.user.reset
+      @game.reset_user
       User.should_receive(:get).and_return(@user)
       @game.user.should == @user
     end
@@ -238,87 +238,97 @@ describe Toy::Reference do
     end
   end
 
-  context "delegating" do
-    describe "when target is nil" do
-      before do
-        @game = Game.create
-      end
+  context "when target is nil" do
+    before do
+      @game = Game.create
+    end
 
-      it "returns nil if nil" do
-        @game.user.inspect.should == 'nil'
-      end
+    it "returns nil if nil" do
+      @game.user.inspect.should == 'nil'
+    end
 
-      it "delegates #kind_of?" do
-        @game.user.kind_of?(NilClass).should be_true
-        @game.user.kind_of?(User).should be_false
-      end
+    it "returns true for nil?" do
+      @game.user.nil?.should be_true
+    end
 
-      it "delegates #instance_of?" do
-        @game.user.instance_of?(NilClass).should be_true
-        @game.user.instance_of?(User).should be_false
-      end
+    it "does not evaluate to true if used in conditional" do
+      lambda { raise if @game.user }.should_not raise_error
+    end
 
-      it "delegates #is_a?" do
-        @game.user.is_a?(NilClass).should be_true
-        @game.user.is_a?(User).should be_false
-      end
+    it "returns true when prefaced with !" do
+      (!@game.user).should == true
+    end
 
-      it "delegates #eql?" do
-        @game.user.should eql(nil)
-        @game.user.should_not eql(User.create)
-        @game.user.should_not eql(@game)
-      end
+    it "delegates #kind_of?" do
+      @game.user.kind_of?(NilClass).should be_true
+      @game.user.kind_of?(User).should be_false
+    end
 
-      it "delegates #equal?" do
-        @game.user.should equal(nil)
-        @game.user.should_not equal(User.create)
-        @game.user.should_not equal(@game)
-      end
+    it "delegates #instance_of?" do
+      @game.user.instance_of?(NilClass).should be_true
+      @game.user.instance_of?(User).should be_false
     end
 
-    describe "when target is not nil" do
-      before do
-        @user = User.create
-        @game = Game.create(:user => @user)
-      end
+    it "delegates #is_a?" do
+      @game.user.is_a?(NilClass).should be_true
+      @game.user.is_a?(User).should be_false
+    end
 
-      it "delegates #inspect" do
-        @game.user = @user
-        @game.user.inspect.should == %Q(#<User:#{@user.object_id} id: "#{@user.id}">)
-      end
+    it "delegates #eql?" do
+      @game.user.should eql(nil)
+      @game.user.should_not eql(User.create)
+      @game.user.should_not eql(@game)
+    end
 
-      it "delegates #==" do
-        (@game.user == @user).should be_true
-        (@user == @game.user).should be_true
-      end
+    it "delegates #equal?" do
+      @game.user.should equal(nil)
+      @game.user.should_not equal(User.create)
+      @game.user.should_not equal(@game)
+    end
+  end
 
-      it "delegates #is_a?" do
-        @game.user.is_a?(User).should be_true
-        @game.user.is_a?(Game).should be_false
-      end
+  context "when target is not nil" do
+    before do
+      @user = User.create
+      @game = Game.create(:user => @user)
+    end
 
-      it "delegates #kind_of?" do
-        @game.user.kind_of?(User).should be_true
-        @game.user.kind_of?(Game).should be_false
-      end
+    it "delegates #inspect" do
+      @game.user = @user
+      @game.user.inspect.should == %Q(#<User:#{@user.object_id} id: "#{@user.id}">)
+    end
 
-      it "delegates #instance_of?" do
-        @game.user.instance_of?(User).should be_true
-        @game.user.instance_of?(Game).should be_false
-      end
+    it "delegates #==" do
+      (@game.user == @user).should be_true
+      (@user == @game.user).should be_true
+    end
 
-      it "delegates #eql?" do
-        @game.user.should eql(@user)
-        @game.user.should_not eql(User.create)
-        @game.user.should_not eql(@game)
-      end
+    it "delegates #is_a?" do
+      @game.user.is_a?(User).should be_true
+      @game.user.is_a?(Game).should be_false
+    end
 
-      it "delegates #equal?" do
-        @game.user.should equal(@user)
-        @user.should equal(@game.user)
-        @game.user.should_not equal(User.create)
-        @game.user.should_not equal(@game)
-      end
+    it "delegates #kind_of?" do
+      @game.user.kind_of?(User).should be_true
+      @game.user.kind_of?(Game).should be_false
+    end
+
+    it "delegates #instance_of?" do
+      @game.user.instance_of?(User).should be_true
+      @game.user.instance_of?(Game).should be_false
+    end
+
+    it "delegates #eql?" do
+      @game.user.should eql(@user)
+      @game.user.should_not eql(User.create)
+      @game.user.should_not eql(@game)
+    end
+
+    it "delegates #equal?" do
+      @game.user.should equal(@user)
+      @user.should equal(@game.user)
+      @game.user.should_not equal(User.create)
+      @game.user.should_not equal(@game)
     end
   end
 
@@ -339,7 +349,7 @@ describe Toy::Reference do
   describe "reference#create" do
     before do
       @game = Game.create
-      @user = @game.user.create
+      @user = @game.create_user
     end
 
     it_should_behave_like 'reference#create'
@@ -349,7 +359,7 @@ describe Toy::Reference do
     before do
       User.attribute(:name, String)
       @game = Game.create
-      @user = @game.user.create(:name => 'John')
+      @user = @game.create_user(:name => 'John')
     end
 
     it_should_behave_like 'reference#create'
@@ -374,14 +384,14 @@ describe Toy::Reference do
 
     it "does not save owner" do
       @game.should_not_receive(:save)
-      @game.user.build
+      @game.build_user
     end
   end
 
   describe "reference#build" do
     before do
       @game = Game.create
-      @user = @game.user.build
+      @user = @game.build_user
     end
 
     it_should_behave_like 'reference#build'
@@ -391,7 +401,7 @@ describe Toy::Reference do
     before do
       User.attribute(:name, String)
       @game = Game.create
-      @user = @game.user.build(:name => 'John')
+      @user = @game.build_user(:name => 'John')
     end
 
     it_should_behave_like 'reference#build'

data/spec/toy/serialization_spec.rb

@@ -1,7 +1,7 @@
 require 'helper'
 
 describe Toy::Serialization do
-  uses_constants('User', 'Game', 'Move')
+  uses_objects('User', 'Move')
 
   before do
     User.attribute :name, String
@@ -10,7 +10,7 @@ describe Toy::Serialization do
 
   it "serializes to json" do
     doc = User.new(:name => 'John', :age => 28)
-    ActiveSupport::JSON.decode(doc.to_json).should == {
+    MultiJson.load(doc.to_json).should == {
       'user' => {
         'name' => 'John',
         'id' => doc.id,
@@ -28,7 +28,6 @@ describe Toy::Serialization do
         'age' => 28
       }
     }
-
   end
 
   it "correctly serializes methods" do
@@ -38,124 +37,31 @@ describe Toy::Serialization do
       end
     end
     json = User.new.to_json(:methods => [:foo])
-    ActiveSupport::JSON.decode(json)['user']['foo'].should == {'foo' => 'bar'}
+    MultiJson.load(json)['user']['foo'].should == {'foo' => 'bar'}
   end
 
   it "allows using :only" do
     user = User.new
     json = user.to_json(:only => :id)
-    ActiveSupport::JSON.decode(json).should == {'user' => {'id' => user.id}}
+    MultiJson.load(json).should == {'user' => {'id' => user.id}}
   end
 
   it "allows using :only with strings" do
     user = User.new
     json = user.to_json(:only => 'id')
-    ActiveSupport::JSON.decode(json).should == {'user' => {'id' => user.id}}
+    MultiJson.load(json).should == {'user' => {'id' => user.id}}
   end
 
   it "allows using :except" do
     user = User.new
     json = user.to_json(:except => :id)
-    ActiveSupport::JSON.decode(json)['user'].should_not have_key('id')
+    MultiJson.load(json)['user'].should_not have_key('id')
   end
 
   it "allows using :except with strings" do
     user = User.new
     json = user.to_json(:except => 'id')
-    ActiveSupport::JSON.decode(json)['user'].should_not have_key('id')
-  end
-
-  describe "serializing relationships" do
-    before do
-      User.list :games, :inverse_of => :user
-      Game.reference :user
-    end
-
-    it "should include references" do
-      user = User.create(:name => 'John', :age => 28)
-      game = user.games.create
-
-      ActiveSupport::JSON.decode(game.to_json(:include => [:user])).should == {
-        'game' => {
-          'id'      => game.id,
-          'user_id' => user.id,
-          'user'    => {
-            'name'     => 'John',
-            'game_ids' => [game.id],
-            'id'       => user.id,
-            'age'      => 28,
-          }
-        }
-      }
-    end
-
-    it "should include lists" do
-      user = User.create(:name => 'John', :age => 28)
-      game = user.games.create
-      ActiveSupport::JSON.decode(user.to_json(:include => [:games])).should == {
-        'user' => {
-          'name'     => 'John',
-          'game_ids' => [game.id],
-          'id'       => user.id,
-          'age'      => 28,
-          'games'    => [{'id' => game.id, 'user_id' => user.id}],
-        }
-      }
-    end
-
-    it "should not cause circular reference JSON errors for references" do
-      user = User.create(:name => 'John', :age => 28)
-      game = user.games.create
-
-      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(game.user)).should == {
-        'user' => {
-          'name'     => 'John',
-          'game_ids' => [game.id],
-          'id'       => user.id,
-          'age'      => 28
-        }
-      }
-    end
-
-    it "should not cause circular reference JSON errors for references when called indirectly" do
-      user = User.create(:name => 'John', :age => 28)
-      game = user.games.create
-
-      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode([game.user])).should == [
-        'user' => {
-          'name'     => 'John',
-          'game_ids' => [game.id],
-          'id'       => user.id,
-          'age'      => 28
-        }
-      ]
-    end
-
-    it "should not cause circular reference JSON errors for lists" do
-      user = User.create(:name => 'John', :age => 28)
-      game = user.games.create
-
-      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(user.games)).should ==  [{
-        'game' => {
-          'id'      => game.id,
-          'user_id' => user.id
-        }
-      }]
-    end
-
-    it "should not cause circular reference JSON errors for lists when called indirectly" do
-      user = User.create(:name => 'John', :age => 28)
-      game = user.games.create
-
-      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode({:games => user.games})).should ==  {
-        'games' => [{
-          'game' => {
-            'id'      => game.id,
-            'user_id' => user.id
-          }
-        }]
-      }
-    end
+    MultiJson.load(json)['user'].should_not have_key('id')
   end
 
   describe "serializing specific attributes" do
@@ -191,7 +97,7 @@ describe Toy::Serialization do
       end
 
       move = Move.new(:index => 0, :points => 15, :words => ['QI', 'XI'])
-      ActiveSupport::JSON.decode(move.to_json).should == {
+      MultiJson.load(move.to_json).should == {
        'move' => {
          'id'     => move.id,
          'points' => 15,
@@ -213,7 +119,7 @@ describe Toy::Serialization do
       end
 
       move = Move.new(:index => 0, :points => 15, :words => ['QI', 'XI'])
-      ActiveSupport::JSON.decode(move.to_json).should == {
+      MultiJson.load(move.to_json).should == {
        'move' => {
          'id'                   => move.id,
          'index'                => 0,
@@ -228,18 +134,17 @@ describe Toy::Serialization do
   describe "#serializable_hash" do
     context "with method that is another toystore object" do
       before do
-        Game.reference(:creator, User)
-        @game = Game.create(:creator => User.create)
+        Move.class_eval { attr_accessor :creator }
       end
-      let(:game) { @game }
+
+      let(:move) { Move.new(:creator => User.new) }
 
       it "returns serializable hash of object" do
-        game.serializable_hash(:methods => [:creator]).should == {
-          'id'         => game.id,
-          'creator_id' => game.creator_id,
-          'creator'    => {'id' => game.creator.id}
+        move.serializable_hash(:methods => [:creator]).should == {
+          'id'         => move.id,
+          'creator'    => {'id' => move.creator.id}
         }
       end
     end
   end
-end
+end

data/spec/toy/store_spec.rb

@@ -3,39 +3,25 @@ require 'helper'
 describe Toy::Store do
   uses_constants('User')
 
-  describe "including" do
-    it "adds model naming" do
-      model_name = User.model_name
-      model_name.should           == 'User'
-      model_name.singular.should  == 'user'
-      model_name.plural.should    == 'users'
+  describe "#to_key" do
+    it "returns [id] if persisted" do
+      user = User.create
+      user.to_key.should == [user.id]
     end
 
-    it "adds to_model" do
-      user = User.new
-      user.to_model.should == user
+    it "returns nil if not persisted" do
+      User.new.to_key.should be_nil
     end
+  end
 
-    describe "#to_key" do
-      it "returns [id] if persisted" do
-        user = User.create
-        user.to_key.should == [user.id]
-      end
-
-      it "returns nil if not persisted" do
-        User.new.to_key.should be_nil
-      end
+  describe "#to_param" do
+    it "returns key joined by - if to_key present" do
+      user = User.create
+      user.to_param.should == user.to_key.join('-')
     end
 
-    describe "#to_param" do
-      it "returns key joined by - if to_key present" do
-        user = User.create
-        user.to_param.should == user.to_key.join('-')
-      end
-
-      it "returns nil if to_key nil" do
-        User.new.to_param.should be_nil
-      end
+    it "returns nil if to_key nil" do
+      User.new.to_param.should be_nil
     end
   end
-end
+end